File indexing completed on 2025-08-05 08:16:06
0001 #include "FlagSavev1.h"
0002
0003 #include <phool/PHFlag.h>
0004
0005 #include <cstdint> // for uint64_t
0006 #include <utility> // for pair
0007
0008 class PHObject;
0009
0010 PHObject *
0011 FlagSavev1::CloneMe() const
0012 {
0013 FlagSavev1 *ret = new FlagSavev1();
0014
0015 ret->intflag = this->intflag;
0016 ret->m_uint64flag_map = this->m_uint64flag_map;
0017 ret->doubleflag = this->doubleflag;
0018 ret->floatflag = this->floatflag;
0019 ret->stringflag = this->stringflag;
0020
0021 return ret;
0022 }
0023
0024 int FlagSavev1::isValid() const
0025 {
0026 if (intflag.empty() &&
0027 doubleflag.empty() &&
0028 floatflag.empty() &&
0029 stringflag.empty() &&
0030 m_uint64flag_map.empty())
0031 {
0032 return 0;
0033 }
0034 return 1;
0035 }
0036
0037 void FlagSavev1::identify(std::ostream &out) const
0038 {
0039 out << "identify yourself: I am an FlagSavev1 Object" << std::endl;
0040 PrintIntFlag(out);
0041 Printuint64Flag(out);
0042 PrintDoubleFlag(out);
0043 PrintFloatFlag(out);
0044 PrintStringFlag(out);
0045 return;
0046 }
0047
0048 int FlagSavev1::FillFromPHFlag(const PHFlag *flags, const bool clearold)
0049 {
0050 if (clearold)
0051 {
0052 ClearAll();
0053 }
0054 int iret = FillIntFromPHFlag(flags);
0055 iret += Filluint64FromPHFlag(flags);
0056 iret += FillDoubleFromPHFlag(flags);
0057 iret += FillFloatFromPHFlag(flags);
0058 iret += FillStringFromPHFlag(flags);
0059 return iret;
0060 }
0061
0062 int FlagSavev1::PutFlagsBack(PHFlag *flags, const bool overwrite)
0063 {
0064 int iret = PutIntToPHFlag(flags, overwrite);
0065 iret += Putuint64ToPHFlag(flags, overwrite);
0066 iret += PutDoubleToPHFlag(flags, overwrite);
0067 iret += PutFloatToPHFlag(flags, overwrite);
0068 iret += PutStringToPHFlag(flags, overwrite);
0069 return iret;
0070 }
0071
0072 int FlagSavev1::FillIntFromPHFlag(const PHFlag *flags)
0073 {
0074 std::map<std::string, int>::const_iterator iter;
0075 const std::map<std::string, int> *intm = flags->IntMap();
0076 for (iter = intm->begin(); iter != intm->end(); ++iter)
0077 {
0078 intflag[iter->first] = iter->second;
0079 }
0080 return 0;
0081 }
0082
0083 int FlagSavev1::Filluint64FromPHFlag(const PHFlag *flags)
0084 {
0085 std::map<std::string, uint64_t>::const_iterator iter;
0086 const std::map<std::string, uint64_t> *intm = flags->uint64Map();
0087 for (iter = intm->begin(); iter != intm->end(); ++iter)
0088 {
0089 m_uint64flag_map[iter->first] = iter->second;
0090 }
0091 return 0;
0092 }
0093
0094 int FlagSavev1::FillDoubleFromPHFlag(const PHFlag *flags)
0095 {
0096 std::map<std::string, double>::const_iterator iter;
0097 const std::map<std::string, double> *intm = flags->DoubleMap();
0098 for (iter = intm->begin(); iter != intm->end(); ++iter)
0099 {
0100 doubleflag[iter->first] = iter->second;
0101 }
0102 return 0;
0103 }
0104
0105 int FlagSavev1::FillFloatFromPHFlag(const PHFlag *flags)
0106 {
0107 std::map<std::string, float>::const_iterator iter;
0108 const std::map<std::string, float> *intm = flags->FloatMap();
0109 for (iter = intm->begin(); iter != intm->end(); ++iter)
0110 {
0111 floatflag[iter->first] = iter->second;
0112 }
0113 return 0;
0114 }
0115
0116 int FlagSavev1::FillStringFromPHFlag(const PHFlag *flags)
0117 {
0118 std::map<std::string, std::string>::const_iterator iter;
0119 const std::map<std::string, std::string> *intm = flags->StringMap();
0120 for (iter = intm->begin(); iter != intm->end(); ++iter)
0121 {
0122 std::string input(iter->second);
0123 stringflag[iter->first] = input;
0124 }
0125 return 0;
0126 }
0127
0128
0129 int FlagSavev1::PutIntToPHFlag(PHFlag *flags, const bool overwrite)
0130 {
0131 std::map<std::string, int>::const_iterator iter;
0132 for (iter = intflag.begin(); iter != intflag.end(); ++iter)
0133 {
0134 if (overwrite)
0135 {
0136 flags->set_IntFlag(iter->first, iter->second);
0137 }
0138 else
0139 {
0140 flags->get_IntFlag(iter->first, iter->second);
0141 }
0142 }
0143 return 0;
0144 }
0145
0146 int FlagSavev1::Putuint64ToPHFlag(PHFlag *flags, const bool overwrite)
0147 {
0148 std::map<std::string, uint64_t>::const_iterator iter;
0149 for (iter = m_uint64flag_map.begin(); iter != m_uint64flag_map.end(); ++iter)
0150 {
0151 if (overwrite)
0152 {
0153 flags->set_uint64Flag(iter->first, iter->second);
0154 }
0155 else
0156 {
0157 flags->get_uint64Flag(iter->first, iter->second);
0158 }
0159 }
0160 return 0;
0161 }
0162
0163 int FlagSavev1::PutDoubleToPHFlag(PHFlag *flags, const bool overwrite)
0164 {
0165 std::map<std::string, double>::const_iterator iter;
0166 for (iter = doubleflag.begin(); iter != doubleflag.end(); ++iter)
0167 {
0168 if (overwrite)
0169 {
0170 flags->set_DoubleFlag(iter->first, iter->second);
0171 }
0172 else
0173 {
0174 flags->get_DoubleFlag(iter->first, iter->second);
0175 }
0176 }
0177 return 0;
0178 }
0179
0180 int FlagSavev1::PutFloatToPHFlag(PHFlag *flags, const bool overwrite)
0181 {
0182 std::map<std::string, float>::const_iterator iter;
0183 for (iter = floatflag.begin(); iter != floatflag.end(); ++iter)
0184 {
0185 if (overwrite)
0186 {
0187 flags->set_FloatFlag(iter->first, iter->second);
0188 }
0189 else
0190 {
0191 flags->get_FloatFlag(iter->first, iter->second);
0192 }
0193 }
0194 return 0;
0195 }
0196
0197 int FlagSavev1::PutStringToPHFlag(PHFlag *flags, const bool overwrite)
0198 {
0199 std::map<std::string, std::string>::const_iterator iter;
0200 for (iter = stringflag.begin(); iter != stringflag.end(); ++iter)
0201 {
0202 if (overwrite)
0203 {
0204 flags->set_StringFlag(iter->first, iter->second);
0205 }
0206 else
0207 {
0208 flags->get_StringFlag(iter->first, iter->second);
0209 }
0210 }
0211 return 0;
0212 }
0213
0214 void FlagSavev1::PrintIntFlag(std::ostream &os) const
0215 {
0216 if (intflag.empty())
0217 {
0218 return;
0219 }
0220 std::map<std::string, int>::const_iterator iter;
0221 os << "Int Flags: " << std::endl;
0222 for (iter = intflag.begin(); iter != intflag.end(); ++iter)
0223 {
0224 os << iter->first << ": " << iter->second << std::endl;
0225 }
0226 return;
0227 }
0228
0229 void FlagSavev1::Printuint64Flag(std::ostream &os) const
0230 {
0231 if (m_uint64flag_map.empty())
0232 {
0233 return;
0234 }
0235 std::map<std::string, uint64_t>::const_iterator iter;
0236 os << "UInt64 Flags: " << std::endl;
0237 for (iter = m_uint64flag_map.begin(); iter != m_uint64flag_map.end(); ++iter)
0238 {
0239 os << iter->first << ": " << iter->second << std::endl;
0240 }
0241 return;
0242 }
0243
0244 void FlagSavev1::PrintDoubleFlag(std::ostream &os) const
0245 {
0246 if (doubleflag.empty())
0247 {
0248 return;
0249 }
0250 std::map<std::string, double>::const_iterator iter;
0251 os << "Double Flags: " << std::endl;
0252 for (iter = doubleflag.begin(); iter != doubleflag.end(); ++iter)
0253 {
0254 os << iter->first << ": " << iter->second << std::endl;
0255 }
0256 return;
0257 }
0258
0259 void FlagSavev1::PrintFloatFlag(std::ostream &os) const
0260 {
0261 if (floatflag.empty())
0262 {
0263 return;
0264 }
0265 std::map<std::string, float>::const_iterator iter;
0266 os << "Float Flags: " << std::endl;
0267 for (iter = floatflag.begin(); iter != floatflag.end(); ++iter)
0268 {
0269 os << iter->first << ": " << iter->second << std::endl;
0270 }
0271 return;
0272 }
0273
0274 void FlagSavev1::PrintStringFlag(std::ostream &os) const
0275 {
0276 if (stringflag.empty())
0277 {
0278 return;
0279 }
0280 std::map<std::string, std::string>::const_iterator iter;
0281 os << "String Flags: " << std::endl;
0282 for (iter = stringflag.begin(); iter != stringflag.end(); ++iter)
0283 {
0284 os << iter->first << ": " << iter->second << std::endl;
0285 }
0286 return;
0287 }
0288
0289 void FlagSavev1::ClearAll()
0290 {
0291 intflag.clear();
0292 doubleflag.clear();
0293 floatflag.clear();
0294 stringflag.clear();
0295 m_uint64flag_map.clear();
0296 }
