edmplugin::CacheParser Class Reference

#include <CacheParser.h>

Public Types
typedef std::map< std::string, std::vector< PluginInfo > >	CategoryToInfos
typedef std::map< std::filesystem::path, NameAndTypes >	LoadableToPlugins
typedef std::pair< std::string, std::string >	NameAndType
typedef std::vector< NameAndType >	NameAndTypes

Public Member Functions
	CacheParser (const CacheParser &)=delete
const CacheParser &	operator= (const CacheParser &)=delete

Static Public Member Functions
static void	read (std::istream &, const std::filesystem::path &iDirectory, CategoryToInfos &oOut)
static void	read (std::istream &, LoadableToPlugins &oOut)
static void	write (const CategoryToInfos &, std::ostream &)
static void	write (LoadableToPlugins &iIn, std::ostream &)

Static Private Member Functions
static bool	readline (std::istream &iIn, const std::filesystem::path &iDirectory, unsigned long iRecordNumber, PluginInfo &oInfo, std::string &oPluginType)
static std::string &	replaceSpaces (std::string &io)
static std::string &	restoreSpaces (std::string &io)

Friends
class	::TestCacheParser

Detailed Description

Definition at line 39 of file CacheParser.h.

Member Typedef Documentation

CategoryToInfos

typedef std::map<std::string, std::vector<PluginInfo> > edmplugin::CacheParser::CategoryToInfos

Definition at line 41 of file CacheParser.h.

LoadableToPlugins

typedef std::map<std::filesystem::path, NameAndTypes> edmplugin::CacheParser::LoadableToPlugins

Definition at line 44 of file CacheParser.h.

NameAndType

typedef std::pair<std::string, std::string> edmplugin::CacheParser::NameAndType

Definition at line 42 of file CacheParser.h.

NameAndTypes

typedef std::vector<NameAndType> edmplugin::CacheParser::NameAndTypes

Definition at line 43 of file CacheParser.h.

Constructor & Destructor Documentation

CacheParser()

edmplugin::CacheParser::CacheParser ( const CacheParser &  )

delete

Member Function Documentation

operator=()

const CacheParser& edmplugin::CacheParser::operator= ( const CacheParser &  )

delete

read() [1/2]

void CacheParser::read ( std::istream &  iIn, const std::filesystem::path &  iDirectory, CacheParser::CategoryToInfos &  iOut  )

static

The std::vector<PluginInfo>'s in CategoryToInfos are guaranteed to be ordered by PluginInfo.name_ where identical names are ordered by the order they are passed to read. In this way multiple calls to read for different directories will preserve the ordering

Definition at line 120 of file CacheParser.cc.

References info(), readline(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edmIntegrityCheck.PublishToFileSystem::get(), main(), and edmplugin::readCacheFile().

                                                           {
    unsigned long recordNumber = 0;

    std::string pluginType;

    PluginInfo info;

    while (iIn) {
      ++recordNumber;
      if (not readline(iIn, iDirectory, recordNumber, info, pluginType)) {
        break;
      }
      iOut[pluginType].push_back(info);
    }
    //now do a sort which preserves any previous order for files
    for (CacheParser::CategoryToInfos::iterator it = iOut.begin(), itEnd = iOut.end(); it != itEnd; ++it) {
      std::stable_sort(it->second.begin(), it->second.end(), CompPluginInfos());
    }
  }

read() [2/2]

void CacheParser::read ( std::istream &  iIn, LoadableToPlugins &  oOut  )

static

Definition at line 176 of file CacheParser.cc.

References relativeConstraints::empty, info(), castor_dqm_sourceclient_file_cfg::path, readline(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edmIntegrityCheck.PublishToFileSystem::get().

                                                                 {
    unsigned long recordNumber = 0;

    std::string pluginType;

    PluginInfo info;
    NameAndType pat;
    std::filesystem::path empty;

    while (iIn) {
      ++recordNumber;
      if (not readline(iIn, empty, recordNumber, info, pat.second)) {
        break;
      }
      pat.first = info.name_;
      oOut[info.loadable_].push_back(pat);
    }
  }

readline()

bool CacheParser::readline ( std::istream &  iIn, const std::filesystem::path &  iDirectory, unsigned long  iRecordNumber, PluginInfo &  oInfo, std::string &  oPluginType  )

staticprivate

Definition at line 82 of file CacheParser.cc.

References edmplugin::checkForError(), MillePedeFileConverter_cfg::fileName, edmplugin::PluginInfo::loadable_, SiStripPI::max, edmplugin::PluginInfo::name_, crabTemplate::pluginName, restoreSpaces(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by read().

                                                     {
    static const std::string kNewLine("start of new line");
    std::string fileName;
    std::string pluginName;
    iIn >> fileName;
    if (iIn.eof()) {
      return false;
    }
    checkForError(iIn, iRecordNumber, kNewLine);
    CacheParser::restoreSpaces(fileName);
    iIn >> pluginName;
    checkForError(iIn, iRecordNumber, fileName);
    CacheParser::restoreSpaces(pluginName);
    iIn >> oPluginType;
    checkForError(iIn, iRecordNumber, oPluginType);
    CacheParser::restoreSpaces(oPluginType);

    oInfo.loadable_ = iDirectory / fileName;
    oInfo.name_ = pluginName;

    //ignore everything to the end of line
    iIn.ignore(std::numeric_limits<int>::max(), '\n');
    while (iIn.peek() == '\n') {
      iIn.get();
    }
    return true;
  }

replaceSpaces()

std::string & CacheParser::replaceSpaces ( std::string &  io )

staticprivate

Definition at line 195 of file CacheParser.cc.

Referenced by write().

                                                     {
    std::string::size_type index = 0;
    while (std::string::npos != (index = io.find_first_of(" \t\n", index))) {
      io[index] = '%';
    }
    return io;
  }

restoreSpaces()

std::string & CacheParser::restoreSpaces ( std::string &  io )

staticprivate

Definition at line 203 of file CacheParser.cc.

Referenced by readline().

                                                     {
    std::string::size_type index = 0;
    while (std::string::npos != (index = io.find_first_of('%', index))) {
      io[index] = ' ';
    }
    return io;
  }

write() [1/2]

void CacheParser::write ( const CategoryToInfos &  iInfos, std::ostream &  oOut  )

static

Definition at line 142 of file CacheParser.cc.

References Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by pkg.AbstractPkg::generate(), and main().

                                                                         {
    //order the data more to our liking: library then object then type
    LoadableToPlugins ordered;

    for (CategoryToInfos::const_iterator it = iInfos.begin(); it != iInfos.end(); ++it) {
      std::string type(it->first);
      for (std::vector<PluginInfo>::const_iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2) {
        //remove any directory specification
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 47
        std::string loadable(it2->loadable_.filename().string());
#else
        std::string loadable(it2->loadable_.filename());
#endif
        std::string name(it2->name_);
        ordered[loadable].push_back(NameAndType(name, type));
      }
    }
    write(ordered, oOut);
  }

write() [2/2]

void CacheParser::write ( LoadableToPlugins &  iIn, std::ostream &  oOut  )

static

Definition at line 162 of file CacheParser.cc.

References replaceSpaces(), edm::sort_all(), AlCaHLTBitMon_QueryRunRegistry::string, and trackerHitRTTI::vector.

Referenced by pkg.AbstractPkg::generate().

                                                                  {
    for (LoadableToPlugins::iterator it = iIn.begin(); it != iIn.end(); ++it) {
      std::string loadable(it->first.string());
      replaceSpaces(loadable);
      edm::sort_all(it->second);

      for (std::vector<std::pair<std::string, std::string> >::iterator it2 = it->second.begin();
           it2 != it->second.end();
           ++it2) {
        oOut << loadable << " " << replaceSpaces(it2->first) << " " << replaceSpaces(it2->second) << "\n";
      }
    }
  }

Friends And Related Function Documentation

::TestCacheParser

friend class ::TestCacheParser

friend

Definition at line 66 of file CacheParser.h.