FlagSavev1.cc

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file FlagSavev1.cc

#include "FlagSavev1.h"

#include <phool/PHFlag.h>

#include <utility>  // for pair

class PHObject;

PHObject *
FlagSavev1::CloneMe() const
{
  FlagSavev1 *ret = new FlagSavev1();

  ret->intflag = this->intflag;
  ret->doubleflag = this->doubleflag;
  ret->floatflag = this->floatflag;
  ret->stringflag = this->stringflag;

  return ret;
}

int FlagSavev1::isValid() const
{
  if (intflag.empty() &&
      doubleflag.empty() &&
      floatflag.empty() &&
      stringflag.empty())
  {
    return 0;
  }
  return 1;
}

void FlagSavev1::identify(std::ostream &out) const
{
  out << "identify yourself: I am an FlagSavev1 Object" << std::endl;
  PrintIntFlag(out);
  PrintDoubleFlag(out);
  PrintFloatFlag(out);
  PrintStringFlag(out);
  return;
}

int FlagSavev1::FillFromPHFlag(const PHFlag *flags)
{
  int iret = FillIntFromPHFlag(flags);
  iret += FillDoubleFromPHFlag(flags);
  iret += FillFloatFromPHFlag(flags);
  iret += FillCharFromPHFlag(flags);
  return iret;
}

int FlagSavev1::PutFlagsBack(PHFlag *flags)
{
  int iret = PutIntToPHFlag(flags);
  iret += PutDoubleToPHFlag(flags);
  iret += PutFloatToPHFlag(flags);
  iret += PutCharToPHFlag(flags);
  return iret;
}

int FlagSavev1::FillIntFromPHFlag(const PHFlag *flags)
{
  std::map<std::string, int>::const_iterator iter;
  const std::map<std::string, int> *intm = flags->IntMap();
  for (iter = intm->begin(); iter != intm->end(); ++iter)
  {
    intflag[iter->first] = iter->second;
  }
  return 0;
}

int FlagSavev1::FillDoubleFromPHFlag(const PHFlag *flags)
{
  std::map<std::string, double>::const_iterator iter;
  const std::map<std::string, double> *intm = flags->DoubleMap();
  for (iter = intm->begin(); iter != intm->end(); ++iter)
  {
    doubleflag[iter->first] = iter->second;
  }
  return 0;
}

int FlagSavev1::FillFloatFromPHFlag(const PHFlag *flags)
{
  std::map<std::string, float>::const_iterator iter;
  const std::map<std::string, float> *intm = flags->FloatMap();
  for (iter = intm->begin(); iter != intm->end(); ++iter)
  {
    floatflag[iter->first] = iter->second;
  }
  return 0;
}

int FlagSavev1::FillCharFromPHFlag(const PHFlag *flags)
{
  std::map<std::string, std::string>::const_iterator iter;
  const std::map<std::string, std::string> *intm = flags->CharMap();
  for (iter = intm->begin(); iter != intm->end(); ++iter)
  {
    std::string input(iter->second);
    stringflag[iter->first] = input;
  }
  return 0;
}

int FlagSavev1::PutIntToPHFlag(PHFlag *flags)
{
  std::map<std::string, int>::const_iterator iter;
  for (iter = intflag.begin(); iter != intflag.end(); ++iter)
  {
    flags->set_IntFlag(iter->first, iter->second);
  }
  return 0;
}

int FlagSavev1::PutDoubleToPHFlag(PHFlag *flags)
{
  std::map<std::string, double>::const_iterator iter;
  for (iter = doubleflag.begin(); iter != doubleflag.end(); ++iter)
  {
    flags->set_DoubleFlag(iter->first, iter->second);
  }
  return 0;
}

int FlagSavev1::PutFloatToPHFlag(PHFlag *flags)
{
  std::map<std::string, float>::const_iterator iter;
  for (iter = floatflag.begin(); iter != floatflag.end(); ++iter)
  {
    flags->set_FloatFlag(iter->first, iter->second);
  }
  return 0;
}

int FlagSavev1::PutCharToPHFlag(PHFlag *flags)
{
  std::map<std::string, std::string>::const_iterator iter;
  for (iter = stringflag.begin(); iter != stringflag.end(); ++iter)
  {
    flags->set_CharFlag(iter->first, iter->second);
  }
  return 0;
}

void FlagSavev1::PrintIntFlag(std::ostream &os) const
{
  if (intflag.empty())
  {
    return;
  }
  std::map<std::string, int>::const_iterator iter;
  os << "Int Flags: " << std::endl;
  for (iter = intflag.begin(); iter != intflag.end(); ++iter)
  {
    os << iter->first << ": " << iter->second << std::endl;
  }
  return;
}

void FlagSavev1::PrintDoubleFlag(std::ostream &os) const
{
  if (doubleflag.empty())
  {
    return;
  }
  std::map<std::string, double>::const_iterator iter;
  os << "Double Flags: " << std::endl;
  for (iter = doubleflag.begin(); iter != doubleflag.end(); ++iter)
  {
    os << iter->first << ": " << iter->second << std::endl;
  }
  return;
}

void FlagSavev1::PrintFloatFlag(std::ostream &os) const
{
  if (floatflag.empty())
  {
    return;
  }
  std::map<std::string, float>::const_iterator iter;
  os << "Float Flags: " << std::endl;
  for (iter = floatflag.begin(); iter != floatflag.end(); ++iter)
  {
    os << iter->first << ": " << iter->second << std::endl;
  }
  return;
}

void FlagSavev1::PrintStringFlag(std::ostream &os) const
{
  if (stringflag.empty())
  {
    return;
  }
  std::map<std::string, std::string>::const_iterator iter;
  os << "String Flags: " << std::endl;
  for (iter = stringflag.begin(); iter != stringflag.end(); ++iter)
  {
    os << iter->first << ": " << iter->second << std::endl;
  }
  return;
}