#include <ParameterSetConverter.h>

Public Types
typedef std::map< ParameterSetID, ParameterSetID >	ParameterSetIdConverter

typedef std::list< std::string >	StringList

typedef std::map< std::string, std::string >	StringMap

typedef std::list< std::pair< std::string, ParameterSetID > >	StringWithIDList

Public Member Functions
ParameterSetConverter &	operator= (const ParameterSetConverter &)=delete

	ParameterSetConverter (ParameterSetMap const &psetMap, ParameterSetIdConverter &idConverter, bool alreadyByReference)

	ParameterSetConverter (const ParameterSetConverter &)=delete

ParameterSetIdConverter const &	parameterSetIdConverter () const

	~ParameterSetConverter ()

Private Member Functions
void	convertParameterSets ()

void	noConvertParameterSets ()

Private Attributes
std::vector< MainParameterSet >	mainParameterSets_

ParameterSetIdConverter &	parameterSetIdConverter_

StringWithIDList	parameterSets_

StringMap	replace_

std::vector< TriggerPath >	triggerPaths_

Detailed Description

Definition at line 40 of file ParameterSetConverter.h.

Member Typedef Documentation

◆ ParameterSetIdConverter

typedef std::map<ParameterSetID, ParameterSetID> edm::ParameterSetConverter::ParameterSetIdConverter

Definition at line 45 of file ParameterSetConverter.h.

◆ StringList

typedef std::list<std::string> edm::ParameterSetConverter::StringList

Definition at line 42 of file ParameterSetConverter.h.

◆ StringMap

typedef std::map<std::string, std::string> edm::ParameterSetConverter::StringMap

Definition at line 43 of file ParameterSetConverter.h.

◆ StringWithIDList

typedef std::list<std::pair<std::string, ParameterSetID> > edm::ParameterSetConverter::StringWithIDList

Definition at line 44 of file ParameterSetConverter.h.

Constructor & Destructor Documentation

◆ ParameterSetConverter() [1/2]

edm::ParameterSetConverter::ParameterSetConverter	(	ParameterSetMap const &	psetMap,
		ParameterSetIdConverter &	idConverter,
		bool	alreadyByReference
	)

Definition at line 59 of file ParameterSetConverter.cc.

References convertParameterSets(), mps_fire::i, dqmiolumiharvest::j, mainParameterSets_, noConvertParameterSets(), parameterSetIdConverter_, parameterSets_, muonDTDigis_cfi::pset, replace_, AlCaHLTBitMon_QueryRunRegistry::string, and triggerPaths_.

       : parameterSets_(), mainParameterSets_(), triggerPaths_(), replace_(), parameterSetIdConverter_(idConverter) {
     for (ParameterSetMap::const_iterator i = psetMap.begin(), iEnd = psetMap.end(); i != iEnd; ++i) {
       parameterSets_.push_back(std::make_pair(i->second.pset(), i->first));
     }
     if (alreadyByReference) {
       noConvertParameterSets();
     } else {
       replace_.insert(std::make_pair(std::string("=+p({})"), std::string("=+q({})")));
       convertParameterSets();
     }
     for (std::vector<MainParameterSet>::iterator j = mainParameterSets_.begin(), jEnd = mainParameterSets_.end();
          j != jEnd;
          ++j) {
       for (std::vector<TriggerPath>::iterator i = triggerPaths_.begin(), iEnd = triggerPaths_.end(); i != iEnd; ++i) {
         if (i->triggerPaths_ == j->triggerPaths_) {
           j->parameterSet_.addParameter("@trigger_paths", i->parameterSet_);
           break;
         }
       }
     }
     for (std::vector<MainParameterSet>::iterator i = mainParameterSets_.begin(), iEnd = mainParameterSets_.end();
          i != iEnd;
          ++i) {
       ParameterSet& pset = i->parameterSet_;
       pset.registerIt();
       ParameterSetID newID(pset.id());
       if (i->oldID_ != newID && i->oldID_ != ParameterSetID()) {
         parameterSetIdConverter_.insert(std::make_pair(i->oldID_, newID));
       }
     }
   }

◆ ~ParameterSetConverter()

edm::ParameterSetConverter::~ParameterSetConverter ( )

Definition at line 94 of file ParameterSetConverter.cc.

94 {}

◆ ParameterSetConverter() [2/2]

edm::ParameterSetConverter::ParameterSetConverter ( const ParameterSetConverter & )

delete

Member Function Documentation

◆ convertParameterSets()

void edm::ParameterSetConverter::convertParameterSets ( )

private

Definition at line 111 of file ParameterSetConverter.cc.

References StringMap::begin(), findQualityFiles::comma, StringMap::end(), mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, dqmdumpme::k, mainParameterSets_, eostools::move(), parameterSetIdConverter_, parameterSets_, csv2json::pieces, muonDTDigis_cfi::pset, replace_, edm::split(), AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, edm::Hash< I >::toString(), and triggerPaths_.

Referenced by ParameterSetConverter().

                                                    {
     std::string const comma(",");
     std::string const rparam(")");
     std::string const rvparam("})");
     std::string const loldparam("=+P(");
     std::string const loldvparam("=+p({");
     std::string const lparam("=+Q(");
     std::string const lvparam("=+q({");
     bool doItAgain = false;
     for (StringMap::const_iterator j = replace_.begin(), jEnd = replace_.end(); j != jEnd; ++j) {
       for (StringWithIDList::iterator i = parameterSets_.begin(), iEnd = parameterSets_.end(); i != iEnd; ++i) {
         for (std::string::size_type it = i->first.find(j->first); it != std::string::npos;
              it = i->first.find(j->first)) {
           i->first.replace(it, j->first.size(), j->second);
           doItAgain = true;
         }
       }
     }
     for (StringWithIDList::iterator i = parameterSets_.begin(), iEnd = parameterSets_.end(); i != iEnd; ++i) {
       if (i->first.find("+P") == std::string::npos && i->first.find("+p") == std::string::npos) {
         if (i->first.find("@all_sources") != std::string::npos) {
           mainParameterSets_.push_back(MainParameterSet(i->second, i->first));
         } else {
           ParameterSet pset(i->first);
           pset.registerIt();
           std::string& from = i->first;
           std::string to;
           ParameterSetID newID(pset.id());
           newID.toString(to);
           insertIntoReplace(replace_, loldparam, from, rparam, lparam, to, rparam);
           insertIntoReplace(replace_, comma, from, comma, comma, to, comma);
           insertIntoReplace(replace_, comma, from, rvparam, comma, to, rvparam);
           insertIntoReplace(replace_, loldvparam, from, comma, lvparam, to, comma);
           insertIntoReplace(replace_, loldvparam, from, rvparam, lvparam, to, rvparam);
           if (i->second != newID && i->second != ParameterSetID()) {
             parameterSetIdConverter_.insert(std::make_pair(i->second, newID));
           }
           if (i->first.find("@trigger_paths") != std::string::npos) {
             triggerPaths_.push_back(pset);
           }
         }
         StringWithIDList::iterator icopy = i;
         ++i;
         parameterSets_.erase(icopy);
         --i;
         doItAgain = true;
       }
     }
     if (!doItAgain && !parameterSets_.empty()) {
       for (auto const& k : parameterSets_) {
         std::vector<std::string_view> pieces;
         split(std::back_inserter(pieces), k.first, '<', ';', '>');
         for (auto const& i : pieces) {
           std::string_view removeName = i.substr(i.find('+'));
           if (removeName.size() >= 4) {
             if (removeName[1] == 'P') {
               std::string psetString(removeName.begin() + 3, removeName.end() - 1);
               parameterSets_.emplace_back(std::move(psetString), ParameterSetID());
               doItAgain = true;
             } else if (removeName[1] == 'p') {
               std::string_view pvec = removeName.substr(3, removeName.size() - 4);
               std::vector<std::string_view> temp;
               split(std::back_inserter(temp), pvec, '{', ',', '}');
               for (auto const& j : temp) {
                 parameterSets_.emplace_back(j, ParameterSetID());
               }
               doItAgain = true;
             }
           }
         }
       }
     }
     if (doItAgain) {
       convertParameterSets();
     }
   }

◆ noConvertParameterSets()

void edm::ParameterSetConverter::noConvertParameterSets ( )

private

Definition at line 96 of file ParameterSetConverter.cc.

References mps_fire::i, edm::pset::Registry::insertMapped(), edm::pset::Registry::instance(), mainParameterSets_, parameterSets_, muonDTDigis_cfi::pset, and triggerPaths_.

Referenced by ParameterSetConverter().

                                                      {
     for (StringWithIDList::iterator i = parameterSets_.begin(), iEnd = parameterSets_.end(); i != iEnd; ++i) {
       if (i->first.find("@all_sources") != std::string::npos) {
         mainParameterSets_.push_back(MainParameterSet(i->second, i->first));
       } else {
         ParameterSet pset(i->first);
         pset.setID(i->second);
         pset::Registry::instance()->insertMapped(pset);
         if (i->first.find("@trigger_paths") != std::string::npos) {
           triggerPaths_.push_back(pset);
         }
       }
     }
   }