edm::ProductSelectorRules::Rule Class Reference

Public Member Functions
bool	appliesTo (BranchDescription const *branch) const
void	applyToAll (std::vector< BranchSelectState > &branchstates) const
void	applyToOne (BranchDescription const *branch, bool &result) const
	Rule (std::string const &s, std::string const &parameterName, std::string const &owner)

Private Attributes
std::regex	instanceName_
std::regex	moduleLabel_
std::regex	processName_
std::regex	productType_
bool	selectflag_

Detailed Description

Definition at line 52 of file ProductSelectorRules.h.

Constructor & Destructor Documentation

edm::ProductSelectorRules::Rule::Rule	(	std::string const &	s,
		std::string const &	parameterName,
		std::string const &	owner
	)

Definition at line 57 of file ProductSelectorRules.cc.

References edm::errors::Configuration, Exception, mps_fire::i, instanceName_, moduleLabel_, CfgNavigationSchool_cfi::parts, processName_, productType_, selectflag_, findQualityFiles::size, split, AlCaHLTBitMon_QueryRunRegistry::string, and trim().

      : selectflag_(), productType_(), moduleLabel_(), instanceName_(), processName_() {
    if (s.size() < 6)
      throw edm::Exception(edm::errors::Configuration)
          << "Invalid statement in configuration file\n"
          << "In " << owner << " parameter named '" << parameterName << "'\n"
          << "Rule must have at least 6 characters because it must\n"
          << "specify 'keep ' or 'drop ' and also supply a pattern.\n"
          << "This is the invalid output configuration rule:\n"
          << "    " << s << "\n"
          << "Exception thrown from ProductSelectorRules::Rule\n";

    if (s.substr(0, 4) == "keep")
      selectflag_ = true;
    else if (s.substr(0, 4) == "drop")
      selectflag_ = false;
    else
      throw edm::Exception(edm::errors::Configuration)
          << "Invalid statement in configuration file\n"
          << "In " << owner << " parameter named '" << parameterName << "'\n"
          << "Rule must specify 'keep ' or 'drop ' and also supply a pattern.\n"
          << "This is the invalid output configuration rule:\n"
          << "    " << s << "\n"
          << "Exception thrown from ProductSelectorRules::Rule\n";

    if (!std::isspace(s[4])) {
      throw edm::Exception(edm::errors::Configuration)
          << "Invalid statement in configuration file\n"
          << "In " << owner << " parameter named '" << parameterName << "'\n"
          << "In each rule, 'keep' or 'drop' must be followed by a space\n"
          << "This is the invalid output configuration rule:\n"
          << "    " << s << "\n"
          << "Exception thrown from ProductSelectorRules::Rule\n";
    }

    // Now pull apart the std::string to get at the bits and pieces of the
    // specification...

    // Grab from after 'keep/drop ' (note the space!) to the end of
    // the std::string...
    std::string spec(s.begin() + 5, s.end());

    // Trim any leading and trailing whitespace from spec
    boost::trim(spec);

    if (spec == "*")  // special case for wildcard
    {
      productType_ = ".*";
      moduleLabel_ = ".*";
      instanceName_ = ".*";
      processName_ = ".*";
      return;
    } else {
      std::vector<std::string> parts;
      boost::split(parts, spec, boost::is_any_of("_"));

      // The std::vector must contain at least 4 parts
      // and none may be empty.
      bool good = (parts.size() == 4);

      // Require all the std::strings to contain only alphanumberic
      // characters or "*" or "?"
      if (good) {
        for (int i = 0; i < 4; ++i) {
          std::string& field = parts[i];
          int size = field.size();
          for (int j = 0; j < size; ++j) {
            if (!(isalnum(field[j]) || field[j] == '*' || field[j] == '?')) {
              good = false;
            }
          }

          // We are using the boost regex library to deal with the wildcards.
          // The configuration file uses a syntax that accepts "*" and "?"
          // as wildcards so we need to convert these to the syntax used in
          // regular expressions.
          boost::replace_all(parts[i], "*", ".*");
          boost::replace_all(parts[i], "?", ".");
        }
      }

      if (!good) {
        throw edm::Exception(edm::errors::Configuration)
            << "Invalid statement in configuration file\n"
            << "In " << owner << " parameter named '" << parameterName << "'\n"
            << "In each rule, after 'keep ' or 'drop ' there must\n"
            << "be a branch specification of the form 'type_label_instance_process'\n"
            << "There must be 4 fields separated by underscores\n"
            << "The fields can only contain alphanumeric characters and the wildcards * or ?\n"
            << "Alternately, a single * is also allowed for the branch specification\n"
            << "This is the invalid output configuration rule:\n"
            << "    " << s << "\n"
            << "Exception thrown from ProductSelectorRules::Rule\n";
      }

      productType_ = parts[0];
      moduleLabel_ = parts[1];
      instanceName_ = parts[2];
      processName_ = parts[3];
    }
  }

Member Function Documentation

bool edm::ProductSelectorRules::Rule::appliesTo

(

edm::BranchDescription const *

branch

)

const

Definition at line 190 of file ProductSelectorRules.cc.

References edm::BranchDescription::friendlyClassName(), instanceName_, edm::BranchDescription::moduleLabel(), moduleLabel_, edm::BranchDescription::processName(), processName_, edm::BranchDescription::productInstanceName(), and productType_.

Referenced by applyToOne().

                                                                                   {
    return partial_match(productType_, branch->friendlyClassName()) &&
           partial_match(moduleLabel_, branch->moduleLabel()) &&
           partial_match(instanceName_, branch->productInstanceName()) &&
           partial_match(processName_, branch->processName());
  }

void edm::ProductSelectorRules::Rule::applyToAll

(

std::vector< BranchSelectState > &

branchstates

)

const

Definition at line 159 of file ProductSelectorRules.cc.

References applyToOne(), and end.

                                                                                            {
    std::vector<BranchSelectState>::iterator it = branchstates.begin();
    std::vector<BranchSelectState>::iterator end = branchstates.end();
    for (; it != end; ++it)
      applyToOne(it->desc, it->selectMe);
  }

void edm::ProductSelectorRules::Rule::applyToOne	(	edm::BranchDescription const *	branch,
		bool &	result
	)		const

Definition at line 185 of file ProductSelectorRules.cc.

References appliesTo(), and selectflag_.

Referenced by applyToAll().

                                                                                                  {
    if (this->appliesTo(branch))
      result = selectflag_;
  }

Member Data Documentation

std::regex edm::ProductSelectorRules::Rule::instanceName_

private

Definition at line 80 of file ProductSelectorRules.h.

Referenced by appliesTo(), and Rule().

std::regex edm::ProductSelectorRules::Rule::moduleLabel_

private

Definition at line 79 of file ProductSelectorRules.h.

Referenced by appliesTo(), ExternalGeneratorFilter.ExternalGeneratorFilter::insertInto(), Modules.SwitchProducer::insertInto(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), and Rule().

std::regex edm::ProductSelectorRules::Rule::processName_

private

Definition at line 81 of file ProductSelectorRules.h.

Referenced by appliesTo(), and Rule().

std::regex edm::ProductSelectorRules::Rule::productType_

private

Definition at line 78 of file ProductSelectorRules.h.

Referenced by appliesTo(), and Rule().

bool edm::ProductSelectorRules::Rule::selectflag_

private

Definition at line 77 of file ProductSelectorRules.h.

Referenced by applyToOne(), and Rule().