edmplugin::CacheParser Class Reference

#include <CacheParser.h>

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

Static Public Member Functions
static void	read (std::istream &, const boost::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 &)

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

Static Private Member Functions
static bool	readline (std::istream &iIn, const boost::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 40 of file CacheParser.h.

Member Typedef Documentation

CategoryToInfos

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

Definition at line 42 of file CacheParser.h.

LoadableToPlugins

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

Definition at line 45 of file CacheParser.h.

NameAndType

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

Definition at line 43 of file CacheParser.h.

NameAndTypes

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

Definition at line 44 of file CacheParser.h.

Constructor & Destructor Documentation

CacheParser()

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

privatedelete

Member Function Documentation

operator=()

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

privatedelete

read() [1/2]

void CacheParser::read ( std::istream &  iIn, const boost::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.

                                                           {
    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());
    }
  }

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

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

read() [2/2]

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

static

Definition at line 176 of file CacheParser.cc.

                                                                 {
    unsigned long recordNumber = 0;
 
    std::string pluginType;
 
    PluginInfo info;
    NameAndType pat;
    boost::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);
    }
  }

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

Referenced by edmIntegrityCheck.PublishToFileSystem::get().

readline()

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

staticprivate

Definition at line 82 of file CacheParser.cc.

                                                     {
    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;
  }

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

Referenced by read().

replaceSpaces()

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

staticprivate

Definition at line 195 of file CacheParser.cc.

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

Referenced by write().

restoreSpaces()

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

staticprivate

Definition at line 203 of file CacheParser.cc.

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

Referenced by readline().

write() [1/2]

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

static

Definition at line 142 of file CacheParser.cc.

                                                                         {
    //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);
  }

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

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

write() [2/2]

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

static

Definition at line 162 of file CacheParser.cc.

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

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

Referenced by pkg.AbstractPkg::generate().

Friends And Related Function Documentation

::TestCacheParser

friend class ::TestCacheParser

friend

Definition at line 64 of file CacheParser.h.