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

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

Definition at line 42 of file CacheParser.h.

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

Definition at line 45 of file CacheParser.h.

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

Definition at line 43 of file CacheParser.h.

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

Definition at line 44 of file CacheParser.h.

Constructor & Destructor Documentation

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

privatedelete

Member Function Documentation

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

privatedelete

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.

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

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

static

Definition at line 176 of file CacheParser.cc.

References relativeConstraints::empty, info(), edmplugin::PluginInfo::loadable_, edmplugin::PluginInfo::name_, callgraph::path, readline(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edmIntegrityCheck.PublishToFileSystem::get().

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

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.

References edmplugin::checkForError(), MillePedeFileConverter_cfg::fileName, edmplugin::PluginInfo::loadable_, SiStripPI::max, edmplugin::PluginInfo::name_, 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;
  }

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

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

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

static

Definition at line 142 of file CacheParser.cc.

References dataset::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);
  }

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

static

Definition at line 162 of file CacheParser.cc.

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

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

friend class ::TestCacheParser

friend

Definition at line 64 of file CacheParser.h.