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
boost::regex	instanceName_
boost::regex	moduleLabel_
boost::regex	processName_
boost::regex	productType_
bool	selectflag_

Detailed Description

Definition at line 49 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 66 of file ProductSelectorRules.cc.

References edm::errors::Configuration, Exception, i, instanceName_, j, moduleLabel_, contentValuesFiles::parts, processName_, productType_, selectflag_, findQualityFiles::size, split, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                           :
    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";
      }

      // Assign the std::strings to the regex (regular expression) objects
      // If the std::string is empty we skip the assignment and leave
      // the regular expression also empty.

      if (parts[0] != "") productType_  = parts[0];
      if (parts[1] != "") moduleLabel_  = parts[1];
      if (parts[2] != "") instanceName_ = parts[2];
      if (parts[3] != "") processName_  = parts[3];
    }
  }

Member Function Documentation

bool edm::ProductSelectorRules::Rule::appliesTo

(

edm::BranchDescription const *

branch

)

const

Definition at line 216 of file ProductSelectorRules.cc.

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

  {
    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 183 of file ProductSelectorRules.cc.

References 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 209 of file ProductSelectorRules.cc.

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

Member Data Documentation

boost::regex edm::ProductSelectorRules::Rule::instanceName_

private

Definition at line 77 of file ProductSelectorRules.h.

Referenced by Rule().

boost::regex edm::ProductSelectorRules::Rule::moduleLabel_

private

Definition at line 76 of file ProductSelectorRules.h.

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

boost::regex edm::ProductSelectorRules::Rule::processName_

private

Definition at line 78 of file ProductSelectorRules.h.

Referenced by Rule().

boost::regex edm::ProductSelectorRules::Rule::productType_

private

Definition at line 75 of file ProductSelectorRules.h.

Referenced by Rule().

bool edm::ProductSelectorRules::Rule::selectflag_

private

Definition at line 74 of file ProductSelectorRules.h.

Referenced by Rule().