edm::friendlyname Namespace Reference

Functions
static std::string const	emptyString ("")
std::string	friendlyName (std::string const &iFullName)
std::string	handleNamespaces (std::string const &iIn)
std::string	handleTemplateArguments (std::string const &)
static std::regex const	reAIKR (", *edm::helper::AssociationIdenticalKeyReference")
static std::regex const	reAllSpaces (" +")
static std::regex const	reArray ("\\")
static std::regex const	reBeginSpace ("^ +")
static std::regex const	reclangabi ("std::__1::")
static std::regex const	reColons ("::")
static std::regex const	reComma (",")
static std::regex const	reCXX11 ("std::__cxx11::")
static std::regex const	reEndSpace (" +$")
static std::regex const	reLong ("long ")
static std::regex const	reLongLong ("Long64_t")
std::string	removeAllSpaces (std::string const &iIn)
std::string	removeExtraSpaces (std::string const &iIn)
static std::regex const	reOneToMany ("edm::AssociationMap< *edm::OneToMany<(.*?),(.*?), *u[a-z]*> >")
static std::regex const	reOneToManyWithQuality ("edm::AssociationMap<edm::OneToManyWithQuality<(.*?), *(.*?), *(.*?), *u[a-z]*> >")
static std::regex const	reOneToOne ("edm::AssociationMap< *edm::OneToOne<(.*?),(.*?), *u[a-z]*> >")
static std::regex const	reOneToValue ("edm::AssociationMap< *edm::OneToValue<(.*?),(.*?), *u[a-z]*> >")
static std::regex const	reOwnVector ("edm::OwnVector<(.*), *edm::ClonePolicy<\ *> >")
static std::regex const	rePointer ("\")
static std::regex const	reSharedPtr ("std::shared_ptr")
static std::regex const	reSorted ("edm::SortedCollection<(.*), *edm::StrictWeakOrdering<\ *> >")
static std::regex const	reString ("std::basic_string<char>")
static std::regex const	reString2 ("std::string")
static std::regex const	reString3 ("std::basic_string<char,std::char_traits<char> >")
static std::regex const	reTemplateArgs ("[^<]*<(.*)>$")
static std::regex const	reToRangeMap ("edm::RangeMap< *(.*), *(.*), *edm::ClonePolicy<([^>]*)> >")
static std::regex const	reToRefs1 ("edm::RefVector< *(.*)< *(.*) *>, *\ *, *edm::refhelper::FindUsingAdvance< *< *\ *> *, *\ *> *>")
static std::regex const	reToRefs2 ("edm::RefVector< *(.*) *, *(.*) *, *edm::refhelper::FindUsingAdvance< *\, *\ *> *>")
static std::regex const	reToRefsAssoc ("edm::RefVector< *Association(.*) *, *edm::helper(.*), *Association(.*)::Find>")
static std::regex const	reToVector ("edm::AssociationVector<(.*), *(.*), *edm::Ref.*,.*>")
static std::regex const	reULongLong ("ULong64_t")
static std::regex const	reUniquePtr ("^std::unique_ptr")
static std::regex const	reUniquePtrDeleter ("^std::unique_ptr< *(.*), *std::default_delete<> *>")
static std::regex const	reUnorderedMap ("std::unordered_map")
static std::regex const	reUnorderedMapCustomHashKeyEqual ("std::unordered_map< *(.*), *(.*), *(.*) *, *std::equal_to<> *>")
static std::regex const	reUnorderedMapHash ("std::unordered_map< *(.*), *(.*), *std::hash<> *>")
static std::regex const	reUnorderedMapHashKeyEqual ("std::unordered_map< *(.*), *(.*), *std::hash<> *, *std::equal_to<> *>")
static std::regex const	reUnorderedSet ("std::unordered_set")
static std::regex const	reUnorderedSetCustomHashKeyEqual ("std::unordered_set< *(.*), *(.*) *, *std::equal_to<> *>")
static std::regex const	reUnorderedSetHash ("std::unordered_set< *(.*), *std::hash<> *>")
static std::regex const	reUnorderedSetHashKeyEqual ("std::unordered_set< *(.*), *std::hash<> *, *std::equal_to<> *>")
static std::regex const	reUnsigned ("unsigned ")
static std::regex const	reVector ("std::vector")
static std::regex const	reWrapper ("edm::Wrapper<(.*)>")
std::string	standardRenames (std::string const &iIn)
std::string	subFriendlyName (std::string const &iFullName)

Function Documentation

emptyString()

static std::string const edm::friendlyname::emptyString ( ""  )

static

Referenced by edm::service::RandomNumberGeneratorService::fillDescriptions(), handleNamespaces(), CosmicTrackSelector::produce(), reco::modules::HICaloCompatibleTrackSelector::produce(), removeAllSpaces(), and removeExtraSpaces().

friendlyName()

std::string edm::friendlyname::friendlyName

(

std::string const &

iFullName

)

Definition at line 278 of file FriendlyName.cc.

References gather_cfg::cout, debug, handleNamespaces(), hcallasereventfilter2012_cfi::prefix, standardRenames(), and subFriendlyName().

Referenced by edm::EventContentAnalyzer::analyze(), edm::CFWriter::branchesActivate(), edm::MixingModule::branchesActivate(), gen::FortranInstance::enter(), edm::TypeID::friendlyClassName(), edm::TypeWithDict::friendlyClassName(), gen::FortranInstance::leave(), main(), edm::RootFile::RootFile(), TFWLiteSelectorBasic::setupNewFile(), edm::BranchDescription::updateFriendlyClassName(), gen::FortranInstance::upEvnt(), gen::FortranInstance::upInit(), and gen::FortranInstance::~FortranInstance().

                                                       {
      if constexpr (debug) {
        std::cout << "\nfriendlyName for " << iFullName << std::endl;
        prefix = " ";
      }
      typedef oneapi::tbb::concurrent_unordered_map<std::string, std::string> Map;
      static Map s_fillToFriendlyName;
      auto itFound = s_fillToFriendlyName.find(iFullName);
      if (s_fillToFriendlyName.end() == itFound) {
        itFound = s_fillToFriendlyName
                      .insert(Map::value_type(iFullName, handleNamespaces(subFriendlyName(standardRenames(iFullName)))))
                      .first;
      }
      if constexpr (debug) {
        std::cout << "result " << itFound->second << std::endl;
      }
      return itFound->second;
    }

handleNamespaces()

std::string edm::friendlyname::handleNamespaces

(

std::string const &

iIn

)

Definition at line 38 of file FriendlyName.cc.

References emptyString(), and reColons().

Referenced by friendlyName().

{ return std::regex_replace(iIn, reColons, emptyString); }

handleTemplateArguments()

std::string edm::friendlyname::handleTemplateArguments

(

std::string const &

iIn

)

Definition at line 207 of file FriendlyName.cc.

References cms::cuda::assert(), gather_cfg::cout, debug, mps_fire::i, or, hcallasereventfilter2012_cfi::prefix, reComma(), removeExtraSpaces(), mps_fire::result, findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, and subFriendlyName().

Referenced by subFriendlyName().

                                                            {
      using namespace std;
      std::string result = removeExtraSpaces(iIn);
      if constexpr (debug) {
        std::cout << prefix << "handleTemplateArguments " << iIn << " removeExtraSpaces " << result << std::endl;
      }

      // Trick to have every full class name to end with comma to
      // avoid treating the end as a special case
      result += ",";

      std::string result2;
      result2.reserve(iIn.size());
      unsigned int openTemplate = 0;
      bool hadTemplate = false;
      size_t begin = 0;
      for (size_t i = 0, size = result.size(); i < size; ++i) {
        if (result[i] == '<') {
          ++openTemplate;
          hadTemplate = true;
          continue;
        } else if (result[i] == '>') {
          --openTemplate;
        }
        // If we are not within the template arguments of a class template
        // - encountering comma means that we are within a template
        //   argument of some other class template, and we've reached
        //   a point when we should translate the argument class name
        // - encountering colon, but only if the class name so far
        //   itself was a template, we've reached a point when we
        //   should translate the class name
        if (const bool hasComma = result[i] == ',', hasColon = hadTemplate and result[i] == ':';
            openTemplate == 0 and (hasComma or hasColon)) {
          std::string templateClass = result.substr(begin, i - begin);
          if constexpr (debug) {
            std::cout << prefix << " templateClass " << templateClass << std::endl;
          }
          if (hadTemplate) {
            if constexpr (debug) {
              prefix += "  ";
            }
            std::string friendlierName = subFriendlyName(templateClass);
            if constexpr (debug) {
              prefix.pop_back();
              prefix.pop_back();
              std::cout << prefix << " friendlierName " << friendlierName << std::endl;
            }
            result2 += friendlierName;
          } else {
            result2 += templateClass;
          }
          if constexpr (debug) {
            std::cout << prefix << " result2 " << result2 << std::endl;
          }
          // reset counters
          hadTemplate = false;
          begin = i + 1;
          // With colon we need to eat the second colon as well
          if (hasColon) {
            assert(result[begin] == ':');
            ++begin;
          }
        }
      }

      result = regex_replace(result2, reComma, "");
      if constexpr (debug) {
        std::cout << prefix << " reComma " << result << std::endl;
      }
      return result;
    }

reAIKR()

static std::regex const edm::friendlyname::reAIKR ( "  , *edm::helper::AssociationIdenticalKeyReference"    )

static

Referenced by standardRenames().

reAllSpaces()

static std::regex const edm::friendlyname::reAllSpaces ( " +"  )

static

Referenced by removeAllSpaces().

reArray()

static std::regex const edm::friendlyname::reArray ( "\  )

static

Referenced by standardRenames().

reBeginSpace()

static std::regex const edm::friendlyname::reBeginSpace ( "^ +"  )

static

Referenced by removeExtraSpaces().

reclangabi()

static std::regex const edm::friendlyname::reclangabi ( "std::__1::"  )

static

Referenced by standardRenames().

reColons()

static std::regex const edm::friendlyname::reColons ( "::"  )

static

Referenced by handleNamespaces().

reComma()

static std::regex const edm::friendlyname::reComma ( "  , "    )

static

Referenced by handleTemplateArguments().

reCXX11()

static std::regex const edm::friendlyname::reCXX11 ( "std::__cxx11::"  )

static

Referenced by standardRenames().

reEndSpace()

static std::regex const edm::friendlyname::reEndSpace ( " +$"  )

static

Referenced by removeExtraSpaces().

reLong()

static std::regex const edm::friendlyname::reLong ( "long "  )

static

Referenced by standardRenames().

reLongLong()

static std::regex const edm::friendlyname::reLongLong ( "Long64_t"  )

static

Referenced by standardRenames().

removeAllSpaces()

std::string edm::friendlyname::removeAllSpaces

(

std::string const &

iIn

)

Definition at line 44 of file FriendlyName.cc.

References emptyString(), and reAllSpaces().

Referenced by subFriendlyName().

{ return std::regex_replace(iIn, reAllSpaces, emptyString); }

removeExtraSpaces()

std::string edm::friendlyname::removeExtraSpaces

(

std::string const &

iIn

)

Definition at line 40 of file FriendlyName.cc.

References emptyString(), reBeginSpace(), and reEndSpace().

Referenced by handleTemplateArguments(), and subFriendlyName().

                                                      {
      return std::regex_replace(std::regex_replace(iIn, reBeginSpace, emptyString), reEndSpace, emptyString);
    }

reOneToMany()

static std::regex const edm::friendlyname::reOneToMany ( "edm::AssociationMap< *edm::OneToMany<(.*?),(.*?), *u[a-z]*> >"  )

static

Referenced by standardRenames().

reOneToManyWithQuality()

static std::regex const edm::friendlyname::reOneToManyWithQuality ( "edm::AssociationMap<edm::OneToManyWithQuality<(.*?), *(.*?), *(.*?), *u[a-z]*> >"  )

static

Referenced by standardRenames().

reOneToOne()

static std::regex const edm::friendlyname::reOneToOne ( "edm::AssociationMap< *edm::OneToOne<(.*?),(.*?), *u[a-z]*> >"  )

static

Referenced by standardRenames().

reOneToValue()

static std::regex const edm::friendlyname::reOneToValue ( "edm::AssociationMap< *edm::OneToValue<(.*?),(.*?), *u[a-z]*> >"  )

static

Referenced by standardRenames().

reOwnVector()

static std::regex const edm::friendlyname::reOwnVector ( "edm::OwnVector<(.*), *edm::ClonePolicy<> >"  )

static

Referenced by standardRenames().

rePointer()

static std::regex const edm::friendlyname::rePointer ( "\  )

static

Referenced by standardRenames().

reSharedPtr()

static std::regex const edm::friendlyname::reSharedPtr ( "std::shared_ptr"  )

static

Referenced by standardRenames().

reSorted()

static std::regex const edm::friendlyname::reSorted ( "edm::SortedCollection<(.*), *edm::StrictWeakOrdering<> >"  )

static

Referenced by standardRenames().

reString()

static std::regex const edm::friendlyname::reString ( "std::basic_string<char>"  )

static

Referenced by standardRenames().

reString2()

static std::regex const edm::friendlyname::reString2 ( "std::string"  )

static

Referenced by standardRenames().

reString3()

static std::regex const edm::friendlyname::reString3 ( "std::basic_string<char,std::char_traits<char> >"  )

static

Referenced by standardRenames().

reTemplateArgs()

static std::regex const edm::friendlyname::reTemplateArgs ( "*<(.*)>$"  [^<] )

static

Referenced by subFriendlyName().

reToRangeMap()

static std::regex const edm::friendlyname::reToRangeMap ( "edm::RangeMap< *(.*), *(.*), *edm::ClonePolicy<([^>]*)>  , "    )

static

Referenced by standardRenames().

reToRefs1()

static std::regex const edm::friendlyname::reToRefs1 ( "edm::RefVector< *(.*)< *(.*) *>, *\, *edm::refhelper::FindUsingAdvance< *\*> *, *> *>"  )

static

Referenced by standardRenames().

reToRefs2()

static std::regex const edm::friendlyname::reToRefs2 ( "edm::RefVector< *(.*) *, *(.*) *, *edm::refhelper::FindUsingAdvance< *\*> *>"  )

static

Referenced by standardRenames().

reToRefsAssoc()

static std::regex const edm::friendlyname::reToRefsAssoc ( "edm::RefVector< *Association(.*) *, *edm::helper(.*), *Association(.*)::Find>"  )

static

Referenced by standardRenames().

reToVector()

static std::regex const edm::friendlyname::reToVector ( "edm::AssociationVector<(.*), *(.*), *edm::Ref.*,.*>"  )

static

Referenced by standardRenames().

reULongLong()

static std::regex const edm::friendlyname::reULongLong ( "ULong64_t"  )

static

Referenced by standardRenames().

reUniquePtr()

static std::regex const edm::friendlyname::reUniquePtr ( "^std::unique_ptr"  )

static

Referenced by subFriendlyName().

reUniquePtrDeleter()

static std::regex const edm::friendlyname::reUniquePtrDeleter ( "^std::unique_ptr< *(.*), *std::default_delete<\*>"  )

static

Referenced by subFriendlyName().

reUnorderedMap()

static std::regex const edm::friendlyname::reUnorderedMap ( "std::unordered_map"  )

static

Referenced by subFriendlyName().

reUnorderedMapCustomHashKeyEqual()

static std::regex const edm::friendlyname::reUnorderedMapCustomHashKeyEqual ( "std::unordered_map< *(.*), *(.*), *(.*) *, *std::equal_to<\*>"  )

static

Referenced by subFriendlyName().

reUnorderedMapHash()

static std::regex const edm::friendlyname::reUnorderedMapHash ( "std::unordered_map< *(.*), *(.*), *std::hash<\*>"  )

static

Referenced by subFriendlyName().

reUnorderedMapHashKeyEqual()

static std::regex const edm::friendlyname::reUnorderedMapHashKeyEqual ( "std::unordered_map< *(.*), *(.*), *std::hash<\*, *std::equal_to<\*>"  )

static

Referenced by subFriendlyName().

reUnorderedSet()

static std::regex const edm::friendlyname::reUnorderedSet ( "std::unordered_set"  )

static

Referenced by subFriendlyName().

reUnorderedSetCustomHashKeyEqual()

static std::regex const edm::friendlyname::reUnorderedSetCustomHashKeyEqual ( "std::unordered_set< *(.*), *(.*) *, *std::equal_to<\*>"  )

static

Referenced by subFriendlyName().

reUnorderedSetHash()

static std::regex const edm::friendlyname::reUnorderedSetHash ( "std::unordered_set< *(.*), *std::hash<\*>"  )

static

Referenced by subFriendlyName().

reUnorderedSetHashKeyEqual()

static std::regex const edm::friendlyname::reUnorderedSetHashKeyEqual ( "std::unordered_set< *(.*), *std::hash<\*, *std::equal_to<\*>"  )

static

Referenced by subFriendlyName().

reUnsigned()

static std::regex const edm::friendlyname::reUnsigned ( "unsigned "  )

static

Referenced by standardRenames().

reVector()

static std::regex const edm::friendlyname::reVector ( "std::vector"  )

static

Referenced by standardRenames().

reWrapper()

static std::regex const edm::friendlyname::reWrapper ( "edm::Wrapper<(.*)>"  )

static

Referenced by standardRenames().

standardRenames()

std::string edm::friendlyname::standardRenames

(

std::string const &

iIn

)

Definition at line 95 of file FriendlyName.cc.

References Skims_PA_cff::name, reAIKR(), reArray(), reclangabi(), reCXX11(), reLong(), reLongLong(), reOneToMany(), reOneToManyWithQuality(), reOneToOne(), reOneToValue(), reOwnVector(), rePointer(), reSharedPtr(), reSorted(), reString(), reString2(), reString3(), reToRangeMap(), reToRefs1(), reToRefs2(), reToRefsAssoc(), reToVector(), reULongLong(), reUnsigned(), reVector(), reWrapper(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by friendlyName().

                                                    {
      using std::regex;
      using std::regex_replace;
      std::string name = regex_replace(iIn, reWrapper, "$1");
      name = regex_replace(name, rePointer, "ptr");
      name = regex_replace(name, reArray, "As");
      name = regex_replace(name, reAIKR, "");
      name = regex_replace(name, reclangabi, "std::");
      name = regex_replace(name, reCXX11, "std::");
      name = regex_replace(name, reString, "String");
      name = regex_replace(name, reString2, "String");
      name = regex_replace(name, reString3, "String");
      name = regex_replace(name, reSorted, "sSorted<$1>");
      name = regex_replace(name, reULongLong, "ull");
      name = regex_replace(name, reLongLong, "ll");
      name = regex_replace(name, reUnsigned, "u");
      name = regex_replace(name, reLong, "l");
      name = regex_replace(name, reVector, "s");
      name = regex_replace(name, reSharedPtr, "SharedPtr");
      name = regex_replace(name, reOwnVector, "sOwned<$1>");
      name = regex_replace(name, reToVector, "AssociationVector<$1,To,$2>");
      name = regex_replace(name, reOneToOne, "Association<$1,ToOne,$2>");
      name = regex_replace(name, reOneToMany, "Association<$1,ToMany,$2>");
      name = regex_replace(name, reOneToValue, "Association<$1,ToValue,$2>");
      name = regex_replace(name, reOneToManyWithQuality, "Association<$1,ToMany,$2,WithQuantity,$3>");
      name = regex_replace(name, reToRangeMap, "RangeMap<$1,$2>");
      name = regex_replace(name, reToRefs1, "Refs<$1<$2>>");
      name = regex_replace(name, reToRefs2, "Refs<$1,$2>");
      name = regex_replace(name, reToRefsAssoc, "Refs<Association$1>");
      //std::cout <<"standardRenames '"<<name<<"'"<<std::endl;
      return name;
    }

subFriendlyName()

std::string edm::friendlyname::subFriendlyName

(

std::string const &

iFullName

)

Definition at line 129 of file FriendlyName.cc.

References gather_cfg::cout, debug, handleTemplateArguments(), eostools::move(), hcallasereventfilter2012_cfi::prefix, removeAllSpaces(), removeExtraSpaces(), mps_fire::result, reTemplateArgs(), reUniquePtr(), reUniquePtrDeleter(), reUnorderedMap(), reUnorderedMapCustomHashKeyEqual(), reUnorderedMapHash(), reUnorderedMapHashKeyEqual(), reUnorderedSet(), reUnorderedSetCustomHashKeyEqual(), reUnorderedSetHash(), reUnorderedSetHashKeyEqual(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by friendlyName(), and handleTemplateArguments().

                                                          {
      using namespace std;
      std::string result = removeExtraSpaces(iFullName);

      // temporarily remove leading const
      std::string leadingConst;
      if (std::string_view{result}.substr(0, 5) == "const") {
        leadingConst = "const";
        result = removeExtraSpaces(result.substr(5));
      }

      if constexpr (debug) {
        std::cout << prefix << "subFriendlyName iFullName " << iFullName << " result " << result << std::endl;
      }
      // Handle unique_ptr, which may contain the deleter (but handle only std::default_delete)
      {
        auto result2 =
            regex_replace(result, reUniquePtrDeleter, "UniquePtr<$1>", std::regex_constants::format_first_only);
        if (result2 == result) {
          result2 = regex_replace(result, reUniquePtr, "UniquePtr", std::regex_constants::format_first_only);
        }
        result = std::move(result2);
      }
      // insert the leading const back if it was there
      result = leadingConst + result;
      // Handle unordered_set, which may contain a hash and an an equal for the key
      {
        auto result2 =
            regex_replace(result, reUnorderedSetHashKeyEqual, "stduset<$1>", std::regex_constants::format_first_only);
        if (result2 == result) {
          result2 = regex_replace(
              result, reUnorderedSetCustomHashKeyEqual, "stduset<$1, $2>", std::regex_constants::format_first_only);
        }
        if (result2 == result) {
          result2 = regex_replace(result, reUnorderedSetHash, "stduset<$1>", std::regex_constants::format_first_only);
        }
        if (result2 == result) {
          result2 = regex_replace(result, reUnorderedSet, "stduset", std::regex_constants::format_first_only);
        }
        result = std::move(result2);
      }
      // Handle unordered_map, which may contain a hash and an an equal for the key
      {
        auto result2 = regex_replace(
            result, reUnorderedMapHashKeyEqual, "stdumap<$1, $2>", std::regex_constants::format_first_only);
        if (result2 == result) {
          result2 = regex_replace(
              result, reUnorderedMapCustomHashKeyEqual, "stdumap<$1, $2, $3>", std::regex_constants::format_first_only);
        }
        if (result2 == result) {
          result2 =
              regex_replace(result, reUnorderedMapHash, "stdumap<$1, $2>", std::regex_constants::format_first_only);
        }
        if (result2 == result) {
          result2 = regex_replace(result, reUnorderedMap, "stdumap", std::regex_constants::format_first_only);
        }
        result = std::move(result2);
      }
      if (smatch theMatch; regex_match(result, theMatch, reTemplateArgs)) {
        //std::cout <<"found match \""<<theMatch.str(1) <<"\"" <<std::endl;
        //static regex const templateClosing(">$");
        //std::string aMatch = regex_replace(theMatch.str(1),templateClosing,"");
        std::string aMatch = theMatch.str(1);
        if constexpr (debug) {
          prefix += "  ";
        }
        std::string theSub = handleTemplateArguments(aMatch);
        if constexpr (debug) {
          prefix.pop_back();
          prefix.pop_back();
          std::cout << prefix << " aMatch " << aMatch << " theSub " << theSub << std::endl;
        }
        regex const eMatch(std::string("(^[^<]*)<") + aMatch + ">");
        result = regex_replace(result, eMatch, theSub + "$1");
      }
      return removeAllSpaces(result);
    }