PixelAliasList.h

Go to the documentation of this file.

#ifndef PixelAliasList_h
#define PixelAliasList_h
 
#include "CalibFormats/SiPixelObjects/interface/PixelConfigAlias.h"
#include "CalibFormats/SiPixelObjects/interface/PixelConfigList.h"
#include "CalibFormats/SiPixelObjects/interface/PixelVersionAlias.h"
 
#include <cassert>
#include <iostream>
#include <stdlib.h>
#include <map>
 
namespace pos {
  // Added by Dario, May 20th, 2008 =====================================================================
  typedef std::pair<unsigned int, std::string> versionAliasPair;
  typedef std::vector<versionAliasPair> vectorVAPairs;
  typedef std::map<std::string, vectorVAPairs> pathVersionAliasMmap;
  typedef std::map<std::string, std::string> pathAliasPair;
  typedef std::map<std::string, pathAliasPair> pathAliasMmap;
  // End of Dario's addition ============================================================================
  class PixelAliasList {
  public:
    void writefile() {
      std::string directory = std::getenv("PIXELCONFIGURATIONBASE");
 
      std::string filename = directory + "/aliases.txt";
 
      std::ofstream out(filename.c_str());
 
      out << "ConfigurationAliases" << std::endl;
      for (unsigned int i = 0; i < pixelConfigAliases_.size(); i++) {
        PixelConfigAlias& theAlias = pixelConfigAliases_[i];
        out << theAlias.name() << "     " << theAlias.key() << "   ";
 
        unsigned int n = theAlias.nVersionAliases();
        for (unsigned int j = 0; j < n; j++) {
          out << theAlias.versionAliasesPath(j) << "  ";
          out << theAlias.versionAliasesAlias(j) << "  ";
        }
 
        out << ";" << std::endl;
      }
 
      out << "VersionAliases" << std::endl;
      for (unsigned int i = 0; i < pixelVersionAliases_.size(); i++) {
        PixelVersionAlias& theAlias = pixelVersionAliases_[i];
 
        out << theAlias.path() << "  " << theAlias.version() << " " << theAlias.alias() << " ;" << std::endl;
      }
    }
 
    void readfile(std::string filename) {
      std::ifstream in(filename.c_str());
      if (!in.good()) {
        std::cout << "[PixelAliasList::readfile()]\t\tCould not open file:" << filename << std::endl;
      }
      assert(in.good());
 
      // Added by Dario, May 28th, 2008 =====================================================================
      pixelConfigAliases_.clear();
      pixelVersionAliases_.clear();
      aliasMmap.clear();
      versionMmap.clear();
      // End of Dario's addition ============================================================================
 
      std::string tag;
 
      in >> tag;
      while (tag.substr(0, 1) == "#") {
        in.ignore(4096, '\n');  //skips to endl;
        in >> tag;
      }
 
      assert(tag == "ConfigurationAliases");
 
      in >> tag;
 
      while (tag != "VersionAliases") {
        std::string alias = tag;
 
        unsigned int key;
        in >> key;
 
        //std::cout << "[PixelAliasList::readfile()] Alias, key:"<<alias<<" "<<key<<std::endl;
 
        PixelConfigAlias anAlias(alias, key);
 
        in >> tag;
        std::string theAlias = alias;
 
        // Added by Dario, May 20th, 2008 =====================================================================
        pathAliasPair tmpPAPair;
        if (tag == ";") {
          tmpPAPair[""] = " ";
          aliasMmap[theAlias] = tmpPAPair;
        }
        // End of Dario's addition ============================================================================
        while (tag != ";") {
          std::string path;
          std::string alias;
 
          path = tag;
          in >> alias;
          //std::cout << "[PixelAliasList::readfile()] path, alias:"<<path<<" "<<alias<<std::endl;
 
          anAlias.addVersionAlias(path, alias);
          // Added by Dario, May 20th, 2008 =====================================================================
          tmpPAPair[path] = alias;
          aliasMmap[theAlias] = tmpPAPair;
          // End of Dario's addition ============================================================================
          in >> tag;
        }
 
        pixelConfigAliases_.push_back(anAlias);
 
        in >> tag;
      }
 
      assert(tag == "VersionAliases");
 
      std::string path;
      std::string alias;
      unsigned int version;
 
      in >> path;
      in >> version;
      in >> alias;
      in >> tag;
 
      //std::cout << "path version alias tag:"<<path<<" "<<version
      //          <<" "<<alias<<" "<<tag<<std::endl;
 
      // Added by Dario, May 23rd, 2008 =====================================================================
      versionAliasPair tmpVAPair;
      // End of Dario's addition ============================================================================
      while (!in.eof()) {
        assert(tag == ";");
        PixelVersionAlias aVersionAlias(path, version, alias);
        pixelVersionAliases_.push_back(aVersionAlias);
 
        // Added by Dario, May 23rd, 2008 =====================================================================
        tmpVAPair.first = version;
        tmpVAPair.second = alias;
        versionMmap[path].push_back(tmpVAPair);
        // End of Dario's addition ============================================================================
 
        in >> path;
        in >> version;
        in >> alias;
        in >> tag;
      }
 
      in.close();
    }
 
    void insertAlias(PixelConfigAlias& anAlias) {
      for (unsigned int i = 0; i < pixelConfigAliases_.size(); i++) {
        if (pixelConfigAliases_[i].name() == anAlias.name()) {
          std::cout << "[PixelAliasList::insertAlias()]\t\t\tReplacing existing alias:" << anAlias.name() << std::endl;
          pixelConfigAliases_[i] = anAlias;
          return;
        }
      }
      pixelConfigAliases_.push_back(anAlias);
    }
 
    PixelConfigAlias* versionAliases(std::string aliasName) {
      for (unsigned int i = 0; i < pixelConfigAliases_.size(); i++) {
        if (pixelConfigAliases_[i].name() == aliasName) {
          return &(pixelConfigAliases_[i]);
        }
      }
      return 0;
    }
 
    void insertVersionAlias(PixelVersionAlias& anAlias) {
      for (unsigned int i = 0; i < pixelVersionAliases_.size(); i++) {
        if (pixelVersionAliases_[i].alias() == anAlias.alias() && pixelVersionAliases_[i].path() == anAlias.path()) {
          std::cout << "[PixelAliasList::insertVersionAlias()]\t\tReplacing existing version alias:" << anAlias.path()
                    << " " << anAlias.alias() << std::endl;
          pixelVersionAliases_[i] = anAlias;
          return;
        }
      }
      pixelVersionAliases_.push_back(anAlias);
    }
 
    void updateConfigAlias(std::string path, unsigned int version, std::string alias, PixelConfigList& config) {
      //first loop over configuration aliases
      for (unsigned int i = 0; i < pixelConfigAliases_.size(); i++) {
        //std::cout << "Looping over aliases:"<<i<<std::endl;
        for (unsigned int j = 0; j < pixelConfigAliases_[i].nVersionAliases(); j++) {
          //std::cout << "Looping over versionAliases:"<<j<<std::endl;
          if (path == pixelConfigAliases_[i].versionAliasesPath(j) &&
              alias == pixelConfigAliases_[i].versionAliasesAlias(j)) {
            //std::cout << "Making clone!"<<std::endl;
            unsigned int newkey = config.clone(pixelConfigAliases_[i].key(), path, version);
            pixelConfigAliases_[i].setKey(newkey);
          }
        }
      }
    }
 
    std::vector<std::string> getVersionAliases(std::string path) {
      std::vector<std::string> tmp;
      for (unsigned int i = 0; i < pixelVersionAliases_.size(); i++) {
        //std::cout << "path alias:"<<pixelVersionAliases_[i].path()
        //    << pixelVersionAliases_[i].alias() << std::endl;
        if (pixelVersionAliases_[i].path() == path) {
          tmp.push_back(pixelVersionAliases_[i].alias());
        }
      }
      return tmp;
    }
 
    unsigned int getVersion(std::string path, std::string alias) {
      for (unsigned int i = 0; i < pixelVersionAliases_.size(); i++) {
        if (pixelVersionAliases_[i].alias() == alias && pixelVersionAliases_[i].path() == path) {
          return pixelVersionAliases_[i].version();
        }
      }
      assert(0);
      return 0;
    }
 
    // Added by Dario, May 20th, 2008 =====================================================================
    pathVersionAliasMmap getVersionData() { return versionMmap; }
 
    pathVersionAliasMmap getVersionData(std::string koc) {
      pathVersionAliasMmap result;
      for (pathVersionAliasMmap::iterator it = versionMmap.begin(); it != versionMmap.end(); it++) {
        if ((*it).first.find(koc) != std::string::npos) {
          result[(*it).first] = (*it).second;
        }
      }
      return result;
    }
 
    std::vector<pathAliasPair> getConfigAliases(std::string path) {
      std::vector<pathAliasPair> configAliasVector;
      for (pathAliasMmap::iterator it = aliasMmap.begin(); it != aliasMmap.end(); it++) {
        if ((*it).first == path) {
          configAliasVector.push_back((*it).second);
        }
      }
      return configAliasVector;
    }
    // End of Dario's addition ============================================================================
 
    unsigned int nAliases() { return pixelConfigAliases_.size(); }
    std::string name(unsigned int i) { return pixelConfigAliases_[i].name(); }
    unsigned int key(unsigned int i) { return pixelConfigAliases_[i].key(); }
    PixelConfigAlias operator[](unsigned int i) { return pixelConfigAliases_[i]; }
 
    unsigned int nVersionAliases() { return pixelVersionAliases_.size(); }
    std::string path(unsigned int i) { return pixelVersionAliases_[i].path(); }
    unsigned int version(unsigned int i) { return pixelVersionAliases_[i].version(); }
    std::string alias(unsigned int i) { return pixelVersionAliases_[i].alias(); }
 
  private:
    std::vector<PixelConfigAlias> pixelConfigAliases_;
    std::vector<PixelVersionAlias> pixelVersionAliases_;
    // Added by Dario, May 20th, 2008 =====================================================================
    pathAliasMmap aliasMmap;
    pathVersionAliasMmap versionMmap;
    // End of Dario's addition ============================================================================
  };
}  // namespace pos
 
#endif