AsgConfigHelper Namespace Reference

Functions
std::string	findConfigFile (const std::string &input, const std::map< std::string, std::string > &configmap)
unsigned int	findMask (const std::string &input, const std::map< std::string, unsigned int > &maskmap)
std::vector< double >	HelperDouble (const std::string &input, TEnv &env)
std::vector< float >	HelperFloat (const std::string &input, TEnv &env)
std::vector< int >	HelperInt (const std::string &input, TEnv &env)
std::vector< std::string >	HelperString (const std::string &input, TEnv &env)
template<typename T>
bool	strtof (const std::string &input, T &f)
template<typename T>
std::vector< T >	Helper (const std::string &input, TEnv &env)

Function Documentation

findConfigFile()

std::string AsgConfigHelper::findConfigFile	(	const std::string &	input,
		const std::map< std::string, std::string > &	configmap )

Definition at line 15 of file AsgEGammaConfigHelper.cxx.

{
  auto confFile_itr = configmap.find(input);
  if (confFile_itr == configmap.end()) {
    static const asg::AsgMessaging msg("Egamma::AsgConfigHelper");
    msg.msg(MSG::WARNING) << "Key " << input
                          << " not found in map, no config file returned"
                          << endmsg;
    return "";
  }
  return confFile_itr->second;
}

findMask()

unsigned int AsgConfigHelper::findMask	(	const std::string &	input,
		const std::map< std::string, unsigned int > &	maskmap )

Definition at line 30 of file AsgEGammaConfigHelper.cxx.

{
  auto mask_itr = maskmap.find(input);
  if (mask_itr == maskmap.end()) {
    static const asg::AsgMessaging msg("Egamma::AsgConfigHelper");
    msg.msg(MSG::WARNING)
      << "Key " << input
      << " not found in map,  egammaPID::EgPidUndefined mask returned"
      << endmsg;
    // mask has the choice to default to all 1 or all 0 bits, choose the former
    return std::numeric_limits<unsigned int>::max();
  }
  return static_cast<unsigned int>(mask_itr->second);
}

Helper()

template<typename T>

std::vector< T > AsgConfigHelper::Helper	(	const std::string &	input,
		TEnv &	env )

Definition at line 83 of file AsgEGammaConfigHelper.cxx.

{
  std::vector<T> CutVector;
  std::string env_input(env.GetValue(input.c_str(), ""));
  if (!env_input.empty()) {
    std::string::size_type end;
    do {
      end = env_input.find(';');
      T myValue{}; //default init
      if (AsgConfigHelper::strtof(env_input.substr(0, end), myValue)) {
        CutVector.push_back(std::move(myValue));
      }
      if (end != std::string::npos) {
        env_input = env_input.substr(end + 1);
      }
    } while (end != std::string::npos);
  }
  return CutVector;
}

HelperDouble()

std::vector< double > AsgConfigHelper::HelperDouble	(	const std::string &	input,
		TEnv &	env )

Definition at line 106 of file AsgEGammaConfigHelper.cxx.

{
  return AsgConfigHelper::Helper<double>(input, env);
}

HelperFloat()

std::vector< float > AsgConfigHelper::HelperFloat	(	const std::string &	input,
		TEnv &	env )

Definition at line 111 of file AsgEGammaConfigHelper.cxx.

{
  return AsgConfigHelper::Helper<float>(input, env);
}

HelperInt()

std::vector< int > AsgConfigHelper::HelperInt	(	const std::string &	input,
		TEnv &	env )

Definition at line 116 of file AsgEGammaConfigHelper.cxx.

{
  return AsgConfigHelper::Helper<int>(input, env);
}

HelperString()

std::vector< std::string > AsgConfigHelper::HelperString	(	const std::string &	input,
		TEnv &	env )

Definition at line 123 of file AsgEGammaConfigHelper.cxx.

{
  return AsgConfigHelper::Helper<std::string>(input, env);
}

strtof()

template<typename T>

bool AsgConfigHelper::strtof	(	const std::string &	input,
		T &	f )

Definition at line 48 of file AsgEGammaConfigHelper.cxx.

{
  int diff = 0;
  std::string tmp = input;
  std::string::size_type first(0);
  std::string::size_type last(0);
  first = (input.find('#'));
 
  // if we do not find a comment character "#" we are fine
  if (first == std::string::npos) {
    std::istringstream buffer(tmp);
    buffer >> f;
    return true;
  } else {
    // if we have found comment character check if it is inlined between two "#"
    last = (input.find('#', first + 1));
    // if nor error
    if (last == std::string::npos) {
      static const asg::AsgMessaging msg("Egamma::AsgConfigHelper");
      msg.msg(MSG::WARNING) << " Improper comment format , inline comment "
                               "should be enclosed between two #  "
                            << endmsg;
      return false;
    }
    // else if between two "#" remove this part
    diff = last - first;
    tmp = tmp.erase(first, diff + 1);
    std::istringstream buffer(tmp);
    buffer >> f;
    return true;
  }
}