framework/phool/PHFlag.cc

0001 #include "PHFlag.h"
0002
0003 #include <boost/stacktrace.hpp>
0004
0005 #include <fstream>
0006 #include <iostream>
0007 #include <map>
0008 #include <utility>  // for pair
0009
0010 std::string
0011 PHFlag::get_StringFlag(const std::string &name) const
0012 {
0013   std::map<std::string, std::string>::const_iterator iter = m_StringFlagMap.find(name);
0014   if (iter != m_StringFlagMap.end())
0015   {
0016     return iter->second;
0017   }
0018   std::cout << "PHFlag::getString: ERROR Unknown character Flag " << name << std::endl;
0019   PrintStackTrace();
0020   std::cout << "The following flags are implemented: " << std::endl;
0021   Print();
0022   return "";
0023 }
0024
0025 std::string
0026 PHFlag::get_StringFlag(const std::string &name, const std::string &defaultval)
0027 {
0028   std::map<std::string, std::string>::const_iterator iter = m_StringFlagMap.find(name);
0029   if (iter != m_StringFlagMap.end())
0030   {
0031     return iter->second;
0032   }
0033
0034   set_StringFlag(name, defaultval);
0035   return get_StringFlag(name);
0036 }
0037
0038 void PHFlag::set_StringFlag(const std::string &name, const std::string &charstr)
0039 {
0040   m_StringFlagMap[name] = charstr;
0041   return;
0042 }
0043
0044 double PHFlag::get_DoubleFlag(const std::string &name) const
0045 {
0046   std::map<std::string, double>::const_iterator iter = m_DoubleFlagMap.find(name);
0047   if (iter != m_DoubleFlagMap.end())
0048   {
0049     return iter->second;
0050   }
0051   std::cout << "PHFlag::getFlag: ERROR Unknown Double Flag " << name << std::endl;
0052   PrintStackTrace();
0053   std::cout << "The following flags are implemented: " << std::endl;
0054   Print();
0055   return 0.0;
0056 }
0057
0058 double PHFlag::get_DoubleFlag(const std::string &name, const double defaultval)
0059 {
0060   std::map<std::string, double>::const_iterator iter = m_DoubleFlagMap.find(name);
0061   if (iter != m_DoubleFlagMap.end())
0062   {
0063     return iter->second;
0064   }
0065
0066   set_DoubleFlag(name, defaultval);
0067   return get_DoubleFlag(name);
0068 }
0069
0070 void PHFlag::set_DoubleFlag(const std::string &name, const double iflag)
0071 {
0072   m_DoubleFlagMap[name] = iflag;
0073   return;
0074 }
0075
0076 float PHFlag::get_FloatFlag(const std::string &name) const
0077 {
0078   std::map<std::string, float>::const_iterator iter = m_FloatFlagMap.find(name);
0079   if (iter != m_FloatFlagMap.end())
0080   {
0081     return iter->second;
0082   }
0083   std::cout << "PHFlag::getFlag: ERROR Unknown Float Flag " << name << std::endl;
0084   PrintStackTrace();
0085   std::cout << "The following flags are implemented: " << std::endl;
0086   Print();
0087   return 0.0;
0088 }
0089
0090 float PHFlag::get_FloatFlag(const std::string &name, const float defaultval)
0091 {
0092   std::map<std::string, float>::const_iterator iter = m_FloatFlagMap.find(name);
0093   if (iter != m_FloatFlagMap.end())
0094   {
0095     return iter->second;
0096   }
0097
0098   set_FloatFlag(name, defaultval);
0099   return get_FloatFlag(name);
0100 }
0101
0102 void PHFlag::set_FloatFlag(const std::string &name, const float iflag)
0103 {
0104   m_FloatFlagMap[name] = iflag;
0105   return;
0106 }
0107
0108 int PHFlag::get_IntFlag(const std::string &name) const
0109 {
0110   std::map<std::string, int>::const_iterator iter = m_IntFlagMap.find(name);
0111   if (iter != m_IntFlagMap.end())
0112   {
0113     return iter->second;
0114   }
0115   std::cout << "PHFlag::getFlag: ERROR Unknown Int Flag " << name << std::endl;
0116   PrintStackTrace();
0117   std::cout << "The following flags are implemented: " << std::endl;
0118   Print();
0119   return 0;
0120 }
0121
0122 int PHFlag::get_IntFlag(const std::string &name, int defaultval)
0123 {
0124   std::map<std::string, int>::const_iterator iter = m_IntFlagMap.find(name);
0125   if (iter != m_IntFlagMap.end())
0126   {
0127     return iter->second;
0128   }
0129
0130   set_IntFlag(name, defaultval);
0131   return get_IntFlag(name);
0132 }
0133
0134 void PHFlag::set_IntFlag(const std::string &name, const int iflag)
0135 {
0136   m_IntFlagMap[name] = iflag;
0137   return;
0138 }
0139
0140 uint64_t PHFlag::get_uint64Flag(const std::string &name) const
0141 {
0142   std::map<std::string, uint64_t>::const_iterator iter = m_UInt64FlagMap.find(name);
0143   if (iter != m_UInt64FlagMap.end())
0144   {
0145     return iter->second;
0146   }
0147   std::cout << "PHFlag::getFlag: ERROR Unknown uint64 Flag " << name << std::endl;
0148   PrintStackTrace();
0149   std::cout << "The following flags are implemented: " << std::endl;
0150   Print();
0151   return 0;
0152 }
0153
0154 uint64_t PHFlag::get_uint64Flag(const std::string &name, uint64_t defaultval)
0155 {
0156   std::map<std::string, uint64_t>::const_iterator iter = m_UInt64FlagMap.find(name);
0157   if (iter != m_UInt64FlagMap.end())
0158   {
0159     return iter->second;
0160   }
0161
0162   set_uint64Flag(name, defaultval);
0163   return get_uint64Flag(name);
0164 }
0165
0166 void PHFlag::set_uint64Flag(const std::string &name, const uint64_t iflag)
0167 {
0168   m_UInt64FlagMap[name] = iflag;
0169   return;
0170 }
0171
0172 void PHFlag::Print() const
0173 {
0174   PrintIntFlags();
0175   Printuint64Flags();
0176   PrintFloatFlags();
0177   PrintDoubleFlags();
0178   PrintStringFlags();
0179   return;
0180 }
0181
0182 void PHFlag::PrintIntFlags() const
0183 {
0184   // loop over the map and print out the content (name and location in memory)
0185   std::cout << std::endl
0186             << "Integer Flags:" << std::endl;
0187   std::map<std::string, int>::const_iterator intiter;
0188   for (intiter = m_IntFlagMap.begin(); intiter != m_IntFlagMap.end(); ++intiter)
0189   {
0190     std::cout << intiter->first << " is " << intiter->second << std::endl;
0191   }
0192   return;
0193 }
0194
0195 void PHFlag::Printuint64Flags() const
0196 {
0197   // loop over the map and print out the content (name and location in memory)
0198   std::cout << std::endl
0199             << "uint64 Flags:" << std::endl;
0200   std::map<std::string, uint64_t>::const_iterator intiter;
0201   for (intiter = m_UInt64FlagMap.begin(); intiter != m_UInt64FlagMap.end(); ++intiter)
0202   {
0203     std::cout << intiter->first << " is " << intiter->second << std::endl;
0204   }
0205   return;
0206 }
0207
0208 void PHFlag::PrintDoubleFlags() const
0209 {
0210   // loop over the map and print out the content (name and location in memory)
0211   std::cout << std::endl
0212             << "Double Flags:" << std::endl;
0213   std::map<std::string, double>::const_iterator doubleiter;
0214   for (doubleiter = m_DoubleFlagMap.begin(); doubleiter != m_DoubleFlagMap.end(); ++doubleiter)
0215   {
0216     std::cout << doubleiter->first << " is " << doubleiter->second << std::endl;
0217   }
0218   return;
0219 }
0220
0221 void PHFlag::PrintFloatFlags() const
0222 {
0223   // loop over the map and print out the content (name and location in memory)
0224   std::cout << std::endl
0225             << "Float Flags:" << std::endl;
0226   std::map<std::string, float>::const_iterator floatiter;
0227   for (floatiter = m_FloatFlagMap.begin(); floatiter != m_FloatFlagMap.end(); ++floatiter)
0228   {
0229     std::cout << floatiter->first << " is " << floatiter->second << std::endl;
0230   }
0231   return;
0232 }
0233
0234 void PHFlag::PrintStringFlags() const
0235 {
0236   // loop over the map and print out the content (name and location in memory)
0237   std::cout << std::endl
0238             << "String Flags:" << std::endl;
0239   std::map<std::string, std::string>::const_iterator chariter;
0240   for (chariter = m_StringFlagMap.begin(); chariter != m_StringFlagMap.end(); ++chariter)
0241   {
0242     std::cout << chariter->first << " is " << chariter->second << std::endl;
0243   }
0244   return;
0245 }
0246
0247 int PHFlag::FlagExist(const std::string &name) const
0248 {
0249   std::map<std::string, int>::const_iterator iter = m_IntFlagMap.find(name);
0250   if (iter != m_IntFlagMap.end())
0251   {
0252     return 1;
0253   }
0254   std::map<std::string, uint64_t>::const_iterator uiter = m_UInt64FlagMap.find(name);
0255   if (uiter != m_UInt64FlagMap.end())
0256   {
0257     return 1;
0258   }
0259   std::map<std::string, float>::const_iterator fiter = m_FloatFlagMap.find(name);
0260   if (fiter != m_FloatFlagMap.end())
0261   {
0262     return 1;
0263   }
0264   std::map<std::string, double>::const_iterator diter = m_DoubleFlagMap.find(name);
0265   if (diter != m_DoubleFlagMap.end())
0266   {
0267     return 1;
0268   }
0269   std::map<std::string, std::string>::const_iterator citer = m_StringFlagMap.find(name);
0270   if (citer != m_StringFlagMap.end())
0271   {
0272     return 1;
0273   }
0274   return 0;
0275 }
0276
0277 void PHFlag::ReadFromFile(const std::string &name)
0278 {
0279   std::string label;
0280   float fvalue;
0281   int fvaluecount = 0;
0282   double dvalue;
0283   int dvaluecount = 0;
0284   int ivalue;
0285   int ivaluecount = 0;
0286   uint64_t uivalue = 0;
0287   int uivaluecount = 0;
0288   std::string cvalue;
0289   int cvaluecount = 0;
0290   std::string junk;
0291   int junkcount = 0;
0292
0293   std::ifstream infile(name);
0294   while (infile >> label)
0295   {
0296     std::cout << "Label " << label;
0297     if (label.substr(0, 1) == "S")
0298     {
0299       infile >> cvalue;
0300       cvaluecount++;
0301       set_StringFlag(label.substr(1, label.size() - 1), cvalue);
0302       std::cout << " type S read " << cvalue << std::endl;
0303     }
0304     else if (label.substr(0, 1) == "F")
0305     {
0306       infile >> fvalue;
0307       fvaluecount++;
0308       set_FloatFlag(label.substr(1, label.size() - 1), fvalue);
0309       std::cout << " type F read " << fvalue << std::endl;
0310     }
0311     else if (label.substr(0, 1) == "D")
0312     {
0313       infile >> dvalue;
0314       dvaluecount++;
0315       set_DoubleFlag(label.substr(1, label.size() - 1), dvalue);
0316       std::cout << " type D read " << dvalue << std::endl;
0317     }
0318     else if (label.substr(0, 1) == "I")
0319     {
0320       infile >> ivalue;
0321       ivaluecount++;
0322       set_IntFlag(label.substr(1, label.size() - 1), ivalue);
0323       std::cout << " type I read " << ivalue << std::endl;
0324     }
0325     else if (label.substr(0, 1) == "U")
0326     {
0327       infile >> uivalue;
0328       uivaluecount++;
0329       set_uint64Flag(label.substr(1, label.size() - 1), uivalue);
0330       std::cout << " type U read " << uivalue << std::endl;
0331     }
0332     else
0333     {
0334       infile >> junk;
0335       junkcount++;
0336       std::cout << " Junk read " << junk << std::endl;
0337     }
0338   }
0339
0340   std::cout << "Read StringFlags(" << cvaluecount
0341             << ") FloatFlags(" << fvaluecount
0342             << ") DoubleFlags(" << dvaluecount
0343             << ") IntFlags(" << ivaluecount
0344             << ") uint64Flags(" << uivaluecount
0345             << ") JunkEntries(" << junkcount
0346             << ") from file " << name << std::endl;
0347
0348   infile.close();
0349 }
0350
0351 void PHFlag::WriteToFile(const std::string &name)
0352 {
0353   std::ofstream outFile(name);
0354   // loop over the map and write out the content
0355   std::map<std::string, int>::const_iterator intiter;
0356   for (intiter = m_IntFlagMap.begin(); intiter != m_IntFlagMap.end(); ++intiter)
0357   {
0358     outFile << "I" << intiter->first << "\t" << intiter->second << std::endl;
0359   }
0360
0361   std::map<std::string, uint64_t>::const_iterator uintiter;
0362   for (uintiter = m_UInt64FlagMap.begin(); uintiter != m_UInt64FlagMap.end(); ++uintiter)
0363   {
0364     outFile << "U" << uintiter->first << "\t" << uintiter->second << std::endl;
0365   }
0366
0367   std::map<std::string, float>::const_iterator floatiter;
0368   for (floatiter = m_FloatFlagMap.begin(); floatiter != m_FloatFlagMap.end(); ++floatiter)
0369   {
0370     outFile << "F" << floatiter->first << "\t" << floatiter->second << std::endl;
0371   }
0372
0373   int oldprecision = outFile.precision(15);
0374   std::map<std::string, double>::const_iterator doubleiter;
0375   for (doubleiter = m_DoubleFlagMap.begin(); doubleiter != m_DoubleFlagMap.end(); ++doubleiter)
0376   {
0377     outFile << "D" << doubleiter->first << "\t" << doubleiter->second << std::endl;
0378   }
0379   outFile.precision(oldprecision);
0380
0381   std::map<std::string, std::string>::const_iterator chariter;
0382   for (chariter = m_StringFlagMap.begin(); chariter != m_StringFlagMap.end(); ++chariter)
0383   {
0384     outFile << "S" << chariter->first << "\t" << chariter->second << std::endl;
0385   }
0386
0387   outFile.close();
0388 }
0389
0390 void PHFlag::PrintStackTrace() const
0391 {
0392   std::cout << "Called by #3 or #4 in this list: " << std::endl;
0393   std::cout << boost::stacktrace::stacktrace();
0394   std::cout << std::endl;
0395   std::cout << "DO NOT PANIC - this is not a segfault" << std::endl;
0396 }
0397
0398 void PHFlag::ClearFlag(const std::string &name)
0399 {
0400   std::map<std::string, int>::iterator iter = m_IntFlagMap.find(name);
0401   if (iter != m_IntFlagMap.end())
0402   {
0403     m_IntFlagMap.erase(iter);
0404   }
0405   std::map<std::string, uint64_t>::iterator uiter = m_UInt64FlagMap.find(name);
0406   if (uiter != m_UInt64FlagMap.end())
0407   {
0408     m_UInt64FlagMap.erase(uiter);
0409   }
0410   std::map<std::string, double>::iterator diter = m_DoubleFlagMap.find(name);
0411   if (diter != m_DoubleFlagMap.end())
0412   {
0413     m_DoubleFlagMap.erase(diter);
0414   }
0415   std::map<std::string, float>::iterator fiter = m_FloatFlagMap.find(name);
0416   if (fiter != m_FloatFlagMap.end())
0417   {
0418     m_FloatFlagMap.erase(fiter);
0419   }
0420   std::map<std::string, std::string>::iterator citer = m_StringFlagMap.find(name);
0421   if (citer != m_StringFlagMap.end())
0422   {
0423     m_StringFlagMap.erase(citer);
0424   }
0425 }
0426
0427 void PHFlag::ClearAll()
0428 {
0429   m_UInt64FlagMap.clear();
0430   m_IntFlagMap.clear();
0431   m_DoubleFlagMap.clear();
0432   m_FloatFlagMap.clear();
0433   m_StringFlagMap.clear();
0434   return;
0435 }