dqi::ConditionsSingleton Class Reference

#include <ConditionsSingleton.h>

Collaboration diagram for dqi::ConditionsSingleton:

Public Member Functions
void	makeConditionMap (std::map< std::string, std::string > &cmap, const std::string &condition)
bool	conditionsMatch (std::map< std::string, std::string > &refConds, std::map< std::string, std::string > &currentConds) const
std::string	conditionalSelect (std::string inp, const std::string &condition)
void	setCondition (const std::string &c)
const std::string &	getCondition () const
int	getNumReferenceHistos () const
std::string	getNewRefHistoName ()
std::vector< std::string >	getAllReferenceNames (std::string inp) const
std::vector< std::pair< std::string, std::string > >	getConditionReferencePairs (std::string inp) const
void	setNewReferenceName (const std::string &, const std::string &)
std::string	getNewReferenceName (const std::string &, bool quiet=false) const
void	setRefSourceMapping (const TMap *refsourcedata)
std::string	getRefSourceData (const std::string &rawref) const

Static Public Member Functions
static ConditionsSingleton &	getInstance ()

Private Member Functions
	ConditionsSingleton ()=default
	~ConditionsSingleton ()=default
	ConditionsSingleton (const ConditionsSingleton &)=delete
ConditionsSingleton &	operator= (const ConditionsSingleton &)=delete

Private Attributes
int	m_numRefHisto {0}
std::string	m_currentConditions
std::map< std::string, std::string >	m_referenceMap
const TMap *	m_refsourcedata {nullptr}

Detailed Description

Definition at line 17 of file ConditionsSingleton.h.

Constructor & Destructor Documentation

ConditionsSingleton() [1/2]

dqi::ConditionsSingleton::ConditionsSingleton ( )

privatedefault

~ConditionsSingleton()

dqi::ConditionsSingleton::~ConditionsSingleton ( )

privatedefault

ConditionsSingleton() [2/2]

dqi::ConditionsSingleton::ConditionsSingleton ( const ConditionsSingleton &  )

privatedelete

Member Function Documentation

conditionalSelect()

std::string dqi::ConditionsSingleton::conditionalSelect	(	std::string	inp,
		const std::string &	condition
	)

Definition at line 153 of file ConditionsSingleton.cxx.

                                                                                          {
    std::string cleanCond(condition);
    std::erase(cleanCond,' ');//delete all spaces
    std::map<std::string, std::string> condition_map, reference_map;
    makeConditionMap(condition_map, condition);
    std::erase(inp,' ');
    //    if(cleanCond.empty())return inp;
    if(inp.find('=')!=std::string::npos){//we have conditions defined on reference
      typedef boost::tokenizer<boost::char_separator<char> >  tokenizer;
      boost::char_separator<char> refSep(";");//field seperator for conditional references
      boost::char_separator<char> condSep(",:"); //filed seperator for conditions and respective reference
      tokenizer referenceConditionPairs(inp, refSep);
      std::string defaultRef("");
      std::map<std::string,std::string> conditionalReferences;
      for(tokenizer::iterator tok_iter=referenceConditionPairs.begin();
      tok_iter!=referenceConditionPairs.end();++tok_iter){//look at each condition reference pair
    if(std::string((*tok_iter)).find('=')!=std::string::npos){//have conditions defined 
      if(std::string(*tok_iter).find(':')!=std::string::npos){//do a reference split
        std::vector<std::string> conds;
        boost::split(conds,*tok_iter,boost::is_any_of(std::string(":")));
        if(conds.size()>2){
          std::cerr<<"Warning malformed reference \""<<inp<<"\""<<std::endl;
        }else if(conds.size()<2){
          std::cerr<<"Warning malformed reference \""<<inp<<"\""<<std::endl;
          continue;
        }
//      std::cout<<"Conditions = \""<<conds.at(conds.size()-2)
//           <<"\",reference= "<<conds.at(conds.size()-1)<<std::endl;
        reference_map.clear();
        makeConditionMap(reference_map, conds.at(conds.size()-2));
        if (conditionsMatch(reference_map, condition_map)) {
          return conds.at(conds.size()-1);
        }
        //conditionalReferences[conds.at(conds.size()-2)]=conds.at(conds.size()-1);
      }
    }else{// no = sign. Then this should be a default reference.
      if(defaultRef.empty()){
        defaultRef=*tok_iter;
      }else{
        std::cout<<"WARNING! overwriting old default reference \""
             <<defaultRef<<"\" with \""
             <<*tok_iter<<"\""<<std::endl;
        defaultRef=*tok_iter;
      }
//    std::cout<<"Default reference = "<<defaultRef<<std::endl;
    }
      }
      //      if(cleanCond.empty()||conditionalReferences.find(cleanCond)==conditionalReferences.end()){
//  std::cout<<"returning default reference "<<defaultRef<<std::endl;
//  return defaultRef;
//      }
//       std::cout<<"returning reference "<<conditionalReferences[cleanCond]<<std::endl;
//      return conditionalReferences[cleanCond];
      return defaultRef;
    }else{
      return inp;
    }
  }

conditionsMatch()

bool dqi::ConditionsSingleton::conditionsMatch	(	std::map< std::string, std::string > &	refConds,
		std::map< std::string, std::string > &	currentConds
	)		const

Definition at line 141 of file ConditionsSingleton.cxx.

                                                                          {
    for (std::map<std::string, std::string>::const_iterator cond_iter = refConds.begin();
     cond_iter != refConds.end(); ++cond_iter) {
      // reject if reference key is not in current conditions
      if (currentConds.find((*cond_iter).first) == currentConds.end()) return false;
      if ((*cond_iter).second != currentConds[(*cond_iter).first]) return false;
    }
    // all specified reference conditions match
    return true;
  }

getAllReferenceNames()

std::vector< std::string > dqi::ConditionsSingleton::getAllReferenceNames

(

std::string

inp

)

const

Definition at line 65 of file ConditionsSingleton.cxx.

                                                                                    {
    std::erase(inp,' ');
    //    if(cleanCond.empty())return inp;
    //std::set<std::string> referenceSet;
    std::vector<std::string> refs;
 
    if(inp.find('=')!=std::string::npos){//we have conditions defined on reference
      typedef boost::tokenizer<boost::char_separator<char> >  tokenizer;
      boost::char_separator<char> refSep(";");//field seperator for conditional references
      boost::char_separator<char> condSep(",:"); //filed seperator for conditions and respective reference
      tokenizer referenceConditionPairs(inp, refSep);
      std::string defaultRef("");
      for(tokenizer::iterator tok_iter=referenceConditionPairs.begin();
      tok_iter!=referenceConditionPairs.end();++tok_iter){//look at each condition reference pair
    if(std::string((*tok_iter)).find('=')!=std::string::npos){//have conditions defined 
      if(std::string(*tok_iter).find(':')!=std::string::npos){//do a reference split
        std::vector<std::string> conds;
        boost::split(conds,*tok_iter,boost::is_any_of(std::string(":")));
        if(conds.size()>2){
          std::cerr<<"Warning malformed reference \""<<inp<<"\""<<std::endl;
        }else if(conds.size()<2){
          std::cerr<<"Warning malformed reference \""<<inp<<"\""<<std::endl;
          continue;
        }
        refs.push_back(conds.at(conds.size()-1));
        //referenceSet.insert(conds.at(conds.size()-1));
      }
    }else{// no = sign. Then this should be a default reference.
      if(defaultRef.empty()){
        defaultRef=*tok_iter;
      }else{
        std::cout<<"WARNING! overwriting old default reference \""
             <<defaultRef<<"\" with \""
             <<*tok_iter<<"\""<<std::endl;
        defaultRef=*tok_iter;
      }
      std::cout<<"Default reference = "<<defaultRef<<std::endl;
    }
    
      }
      // for(std::set<std::string>::iterator it=referenceSet.begin();it!=referenceSet.end();++it){
      //    refs.push_back(*it);
      // }
      if(!defaultRef.empty())refs.push_back(defaultRef);
      return refs;
    }else{
      refs.push_back(inp);
      return refs;
    }
  }

getCondition()

const std::string & dqi::ConditionsSingleton::getCondition

(

)

const

Definition at line 28 of file ConditionsSingleton.cxx.

                                                           {
    return m_currentConditions;
  }

getConditionReferencePairs()

std::vector< std::pair< std::string, std::string > > dqi::ConditionsSingleton::getConditionReferencePairs

(

std::string

inp

)

const

Definition at line 216 of file ConditionsSingleton.cxx.

                                                                                                              {
    std::vector<std::pair<std::string,std::string> > condPairs;
    std::map<std::string,std::string>  pairMap;//unique condition-reference pairs;
    std::erase(inp,' ');
    std::string defaultRef("");
    if(inp.find('=')!=std::string::npos){//we have conditions defined on reference
      typedef boost::tokenizer<boost::char_separator<char> >  tokenizer;
      boost::char_separator<char> refSep(";");//field seperator for conditional references
      boost::char_separator<char> condSep(",:"); //filed seperator for conditions and respective reference
      tokenizer referenceConditionPairs(inp, refSep);
      std::map<std::string,std::string> conditionalReferences;
      for(tokenizer::iterator tok_iter=referenceConditionPairs.begin();
      tok_iter!=referenceConditionPairs.end();++tok_iter){//look at each condition reference pair
    if(std::string((*tok_iter)).find('=')!=std::string::npos){//have conditions defined 
      if(std::string(*tok_iter).find(':')!=std::string::npos){//do a reference split
        std::vector<std::string> conds;
        boost::split(conds,*tok_iter,boost::is_any_of(std::string(":")));
        if(conds.size()>2){
          std::cerr<<"Warning malformed reference \""<<inp<<"\""<<std::endl;
        }else if(conds.size()<2){
          std::cerr<<"Warning malformed reference \""<<inp<<"\""<<std::endl;
          continue;
        }
        condPairs.push_back(std::make_pair(conds.at(conds.size()-2),conds.at(conds.size()-1)));
        //pairMap[conds.at(conds.size()-2)]=conds.at(conds.size()-1);
      }
    }else{// no = sign. Then this should be a default reference.
      if(defaultRef.empty()){
        defaultRef=*tok_iter;
      }else{
        std::cout<<"WARNING! overwriting old default reference \""
             <<defaultRef<<"\" with \""
             <<*tok_iter<<"\""<<std::endl;
        defaultRef=*tok_iter;
      }
      //      std::cout<<"Default reference = "<<defaultRef<<std::endl;
    }
      }
      // for(std::map<std::string,std::string>::iterator it=pairMap.begin();it!=pairMap.end();++it){
      //    condPairs.push_back(std::make_pair<std::string,std::string>(it->first,it->second));
      // }
      if(!defaultRef.empty())condPairs.push_back(std::make_pair("",defaultRef));
      //return condPairs;
    }else{
      condPairs.push_back(std::make_pair("",inp));
    }
    return condPairs;
  }

getInstance()

ConditionsSingleton & dqi::ConditionsSingleton::getInstance ( )

static

Definition at line 19 of file ConditionsSingleton.cxx.

                                                       {
    static ConditionsSingleton instance;
    return instance;
  }

getNewReferenceName()

std::string dqi::ConditionsSingleton::getNewReferenceName	(	const std::string &	oldName,
		bool	quiet = false
	)		const

Definition at line 281 of file ConditionsSingleton.cxx.

                                                                                              {
    if(oldName.empty()){
      std::cerr<<"Reference must have a name"<<std::endl;
      return {};
    }
 
    const auto itr = m_referenceMap.find(oldName);
    if(itr==m_referenceMap.end()){
      if(!quiet)std::cerr<<"Non-existent reference\""<<oldName<<"\". Returning empty string"<<std::endl;
      return {};
    }
    return itr->second;
  }

getNewRefHistoName()

std::string dqi::ConditionsSingleton::getNewRefHistoName

(

)

Definition at line 57 of file ConditionsSingleton.cxx.

                                                   {
    std::stringstream oss;
    oss<<"reference-"<<std::setfill('0')<<std::setw(9)<<m_numRefHisto;
    m_numRefHisto++;
    //std::cout<<__PRETTY_FUNCTION__<<"new histo name"<<oss.str()<<std::endl;
    return oss.str();
  }

getNumReferenceHistos()

int dqi::ConditionsSingleton::getNumReferenceHistos

(

)

const

Definition at line 31 of file ConditionsSingleton.cxx.

                                                       {
    return m_numRefHisto;
  }

getRefSourceData()

std::string dqi::ConditionsSingleton::getRefSourceData

(

const std::string &

rawref

)

const

Definition at line 42 of file ConditionsSingleton.cxx.

                                                                               {
    if (! m_refsourcedata) {
      // Suppress error message as it will occur in cases of backwards compatibility
      // std::cerr << "Null refsourcedata: THIS IS REALLY BAD!!!" << std::endl;
      return "";
    }
    const TObjString* value = dynamic_cast<TObjString*>(m_refsourcedata->GetValue(rawref.c_str()));
    if (!value) {
      std::cerr << "Unable to figure out refsource mapping: THIS IS ALSO REALLY BAD!!!" << std::endl;
      std::cerr << "This happened for reference " << rawref << std::endl;
      return "";
    }
    return value->GetName();
  }

makeConditionMap()

void dqi::ConditionsSingleton::makeConditionMap	(	std::map< std::string, std::string > &	cmap,
		const std::string &	condition
	)

Definition at line 116 of file ConditionsSingleton.cxx.

                                                    {
    if (condition.empty()) return;
 
    typedef boost::tokenizer<boost::char_separator<char> >  tokenizer;
    std::string cleanCond(condition);
    std::erase(cleanCond,' ');//delete all spaces
    boost::char_separator<char> condSep(","); //filed seperator for conditions and respective reference
    tokenizer conditionPairs(condition, condSep);
    for (tokenizer::const_iterator tok_iter = conditionPairs.begin();
     tok_iter != conditionPairs.end(); ++tok_iter) {
      std::vector<std::string> splitpairs;
      boost::split(splitpairs, *tok_iter, boost::is_any_of(std::string("=")));
      if (splitpairs.size() != 2) {
    std::cerr << "WARNING: malformed condition \"" << *tok_iter << "\"" << std::endl;
    continue;
      } else {
    if (cmap.find(splitpairs[0]) != cmap.end()) {
      std::cerr << "WARNING: redefinition of condition " << splitpairs[0] << std::endl;
    }
    cmap[splitpairs[0]] = splitpairs[1];
      }
    }
  }

operator=()

ConditionsSingleton& dqi::ConditionsSingleton::operator= ( const ConditionsSingleton &  )

privatedelete

setCondition()

void dqi::ConditionsSingleton::setCondition

(

const std::string &

c

)

Definition at line 24 of file ConditionsSingleton.cxx.

                                                             {
    m_currentConditions=cond;
  }

setNewReferenceName()

void dqi::ConditionsSingleton::setNewReferenceName	(	const std::string &	oldName,
		const std::string &	newName
	)

Definition at line 264 of file ConditionsSingleton.cxx.

                                                                                                {
    if(oldName.empty()){
      std::cerr<<"Warning old name of the reference is empty. New name is \""<<newName<<"\""<<std::endl;
      return;
    }
    if(newName.empty()){
      std::cerr<<"Warning new name of the reference is empty. Old name is \""<<oldName<<"\""<<std::endl;
      return;
    }
    if(m_referenceMap.find(oldName)==m_referenceMap.end()){
      m_referenceMap[oldName]=newName;
    }else{
      std::cerr<<"Warning reference \""<<oldName<<"\" is added to map before as \""
           << m_referenceMap[oldName]<<"\". New name is \""<<newName<<"\""<<std::endl;
      return;
    }
  }

setRefSourceMapping()

void dqi::ConditionsSingleton::setRefSourceMapping

(

const TMap *

refsourcedata

)

Definition at line 35 of file ConditionsSingleton.cxx.

                                                                         {
    if (! refsourcedata) {
      std::cerr << "You are setting a bad refsourcedata! This will cause you trouble later!" << std::endl;
    }
    m_refsourcedata = refsourcedata;
  }

Member Data Documentation

m_currentConditions

std::string dqi::ConditionsSingleton::m_currentConditions

private

Definition at line 25 of file ConditionsSingleton.h.

m_numRefHisto

int dqi::ConditionsSingleton::m_numRefHisto {0}

private

Definition at line 24 of file ConditionsSingleton.h.

m_referenceMap

std::map<std::string,std::string> dqi::ConditionsSingleton::m_referenceMap

private

Definition at line 26 of file ConditionsSingleton.h.

m_refsourcedata

const TMap* dqi::ConditionsSingleton::m_refsourcedata {nullptr}

private

Definition at line 27 of file ConditionsSingleton.h.

---

The documentation for this class was generated from the following files:

• ConditionsSingleton.h
• ConditionsSingleton.cxx