/data/git/CMSSW_5_3_11_patch5/src/GeneratorInterface/Core/src/ParameterCollector.cc

Go to the documentation of this file.

#include <ostream>
#include <cstdlib>
#include <vector>
#include <string>
#include <map>

#include "FWCore/Utilities/interface/EDMException.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "GeneratorInterface/Core/interface/ParameterCollector.h"

using namespace gen;

ParameterCollector::ParameterCollector()
{
}

ParameterCollector::ParameterCollector(const edm::ParameterSet &pset)
{
   std::vector<std::string> names =
                pset.getParameterNamesForType<std::vector<std::string> >();

   for(std::vector<std::string>::const_iterator it = names.begin();
       it != names.end(); ++it)
      contents_[*it] = pset.getParameter<std::vector<std::string> >(*it);
}

ParameterCollector::~ParameterCollector()
{
}

inline ParameterCollector::const_iterator::const_iterator(
                        const ParameterCollector *collector,
                        std::vector<std::string>::const_iterator begin,
                        std::vector<std::string>::const_iterator end,
                        bool special, std::ostream *dump)
   : collector_(collector), dump_(dump), special_(special)
{
   if (begin != end)
      iter_.push_back(IterPair(begin, end));

   next();
}

void ParameterCollector::const_iterator::increment()
{
   if (++iter_.back().first == iter_.back().second)
      iter_.pop_back();

   next();
}

void ParameterCollector::const_iterator::next()
{
   if (iter_.empty()) {
      cache_.clear();
      return;
   }

   for(;;) {
      const std::string &line = *iter_.back().first;

      bool special = special_ && iter_.size() == 1;
      if ( (!line.empty() && line[0] == '+') || special) {
         if (++iter_.back().first == iter_.back().second) {
            iter_.pop_back();
            if (iter_.empty())
              special_ = false;
         }

         std::string block = special ? line : line.substr(1);

         std::map<std::string, std::vector<std::string> >::const_iterator
                                        pos = collector_->contents_.find(block);
           if (pos == collector_->contents_.end())
              throw edm::Exception(edm::errors::Configuration)
                 << "ParameterCollector could not find configuration lines "
                    "block \"" << block << "\", included via plus sign.";

           if (dump_)
              *dump_ << "\n####### " << block << " #######" << std::endl;

           if (!pos->second.empty())
              iter_.push_back(IterPair(pos->second.begin(),
                                       pos->second.end()));
      } else {
         cache_ = collector_->resolve(line);
         if (dump_)
            *dump_ << cache_ << std::endl;
         break;
      }
   }
}

ParameterCollector::const_iterator ParameterCollector::begin() const
{
   std::map<std::string, std::vector<std::string> >::const_iterator
                                        pos = contents_.find("parameterSets");
   if (pos == contents_.end())
      throw edm::Exception(edm::errors::Configuration)
         << "ParameterCollector could not find \"parameterSets\" block.";

   return const_iterator(this, pos->second.begin(), pos->second.end(), true);
}

ParameterCollector::const_iterator ParameterCollector::begin(std::ostream &dump) const
{
   std::map<std::string, std::vector<std::string> >::const_iterator
                                        pos = contents_.find("parameterSets");
   if (pos == contents_.end())
      throw edm::Exception(edm::errors::Configuration)
         << "ParameterCollector could not find \"parameterSets\" block.";

   return const_iterator(this, pos->second.begin(), pos->second.end(),
                         true, &dump);
}

ParameterCollector::const_iterator ParameterCollector::begin(const std::string &block) const
{
   std::map<std::string, std::vector<std::string> >::const_iterator
                                                pos = contents_.find(block);
   if (pos == contents_.end())
      throw edm::Exception(edm::errors::Configuration)
         << "ParameterCollector could not find \"" << block << "\" block.";

   return const_iterator(this, pos->second.begin(), pos->second.end());
}

ParameterCollector::const_iterator ParameterCollector::begin(const std::string &block, std::ostream &dump) const
{
   std::map<std::string, std::vector<std::string> >::const_iterator
                                                pos = contents_.find(block);
   if (pos == contents_.end())
      throw edm::Exception(edm::errors::Configuration)
         << "ParameterCollector could not find \"" << block << "\" block.";

   dump << "\n####### " << block << " #######" << std::endl;

   return const_iterator(this, pos->second.begin(), pos->second.end(),
                         false, &dump);
}

std::string ParameterCollector::resolve(const std::string &line)
{
   std::string result(line);

   for(;;) {
      std::string::size_type pos = result.find("${");
      if (pos == std::string::npos)
         break;

      std::string::size_type endpos = result.find('}', pos);
      if (endpos == std::string::npos)
         break;
      else
         ++endpos;

      std::string var = result.substr(pos + 2, endpos - pos - 3);
      const char *path = std::getenv(var.c_str());

      result.replace(pos, endpos - pos, path ? path : "");
   }

   return result;
}