Provenance/src/ProductNamePattern.cc

0001 #include <algorithm>
0002 #include <string>
0003 #include <string_view>
0004 #include <regex>
0005 #include <vector>
0006
0007 #include <boost/algorithm/string/replace.hpp>
0008
0009 #include "DataFormats/Provenance/interface/ProductNamePattern.h"
0010 #include "FWCore/Utilities/interface/EDMException.h"
0011
0012 namespace edm {
0013
0014   /* glob_to_regex
0015    *
0016    * Utility function to convert a shell-like glob expression to a regex.
0017    */
0018   static std::regex glob_to_regex(std::string pattern) {
0019     boost::replace_all(pattern, "*", ".*");
0020     boost::replace_all(pattern, "?", ".");
0021     return std::regex(pattern);
0022   }
0023
0024   /* ProductNamePattern
0025    *
0026    * A ProductNamePattern is constructed from a string representing either a module label (e.g. "<module label>") or a
0027    * a branch name (e.g. "<product type>_<module label>_<instance name>_<process name>").
0028    *
0029    * For transient products, the module label may contain additional underscores.
0030    *
0031    * See DataFormats/Provenance/interface/ProductNamePattern.h for more details.
0032    */
0033   ProductNamePattern::ProductNamePattern(std::string const& label) {
0034     static constexpr char kSeparator = '_';
0035     static constexpr std::string_view kWildcard{"*"};
0036     static const std::regex kAny{".*"};
0037     static const std::regex kFields{"([a-zA-Z0-9*]+)_([a-zA-Z0-9_*]+)_([a-zA-Z0-9*]*)_([a-zA-Z0-9*]+)"};
0038
0039     // empty label
0040     if (label.empty()) {
0041       throw edm::Exception(edm::errors::Configuration) << "Invalid module label or branch name: \"" << label << "\"";
0042     }
0043
0044     // wildcard
0045     if (label == kWildcard) {
0046       type_ = kAny;
0047       moduleLabel_ = kAny;
0048       productInstanceName_ = kAny;
0049       processName_ = kAny;
0050       return;
0051     }
0052
0053     int underscores = std::count(label.begin(), label.end(), kSeparator);
0054     if (underscores == 0) {
0055       // Convert the module label into a regular expression.
0056       type_ = kAny;
0057       moduleLabel_ = glob_to_regex(label);
0058       productInstanceName_ = kAny;
0059       processName_ = kAny;
0060       return;
0061     }
0062
0063     if (underscores >= 3) {
0064       // Split the branch name into <product type>_<module label>_<instance name>_<process name>
0065       // and convert the glob expressions into regular expressions.
0066       // Note that:
0067       //   - the <instance name> may be empty;
0068       //   - for non-persistable branches, <module label> may contain additional underscores.
0069       std::smatch fields;
0070       if (std::regex_match(label, fields, kFields)) {
0071         type_ = glob_to_regex(fields[1]);
0072         moduleLabel_ = glob_to_regex(fields[2]);
0073         productInstanceName_ = glob_to_regex(fields[3]);
0074         processName_ = glob_to_regex(fields[4]);
0075         return;
0076       }
0077     }
0078
0079     // Invalid input.
0080     throw edm::Exception(edm::errors::Configuration) << "Invalid module label or branch name: \"" << label << "\"";
0081   }
0082
0083   /* ProductNamePattern::match
0084    *
0085    * Compare a ProductNamePattern object with a ProductDescription object.
0086    */
0087   bool ProductNamePattern::match(edm::ProductDescription const& product) const {
0088     return (std::regex_match(product.friendlyClassName(), type_) and
0089             std::regex_match(product.moduleLabel(), moduleLabel_) and
0090             std::regex_match(product.productInstanceName(), productInstanceName_) and
0091             std::regex_match(product.processName(), processName_));
0092   }
0093
0094   /* productPatterns
0095    *
0096    * Utility function to construct a vector<edm::ProductNamePattern> from a vector<std::string>.
0097    */
0098   std::vector<ProductNamePattern> productPatterns(std::vector<std::string> const& labels) {
0099     std::vector<ProductNamePattern> patterns;
0100     patterns.reserve(labels.size());
0101     for (auto const& label : labels)
0102       patterns.emplace_back(label);
0103     return patterns;
0104   }
0105
0106 }  // namespace edm