ConfigurationDatabase.cc

Go to the documentation of this file.

#include "CaloOnlineTools/HcalOnlineDb/interface/ConfigurationDatabaseImpl.hh"
#include "CaloOnlineTools/HcalOnlineDb/interface/ConfigurationDatabase.hh"
#include "CaloOnlineTools/HcalOnlineDb/interface/ConfigurationItemNotFoundException.hh"
#include "CaloOnlineTools/HcalOnlineDb/interface/PluginManager.hh"
#include <cctype>

#ifdef HAVE_XDAQ
#include <toolbox/string.h>
#else
#include "CaloOnlineTools/HcalOnlineDb/interface/xdaq_compat.h"  // Includes typedef for log4cplus::Logger
#endif

namespace hcal {

  ConfigurationDatabase::ConfigurationDatabase(log4cplus::Logger logger) : m_logger(logger) {
    m_implementation=nullptr;
  }

  void ConfigurationDatabase::open(const std::string& accessor) noexcept(false) {
    if (m_implementationOptions.empty()) {
      std::vector<hcal::AbstractPluginFactory*> facts;
      hcal::PluginManager::getFactories("hcal::ConfigurationDatabaseImpl",facts);
      for (std::vector<hcal::AbstractPluginFactory*>::iterator j=facts.begin(); j!=facts.end(); j++)
        m_implementationOptions.push_back(dynamic_cast<hcal::ConfigurationDatabaseImpl*>((*j)->newInstance()));
    }

    std::map<std::string,std::string> params;
    std::string user, host, method, db, port,password;
    ConfigurationDatabaseImpl::parseAccessor(accessor,method,host,port,user,db,params);

    if (m_implementation==nullptr || !m_implementation->canHandleMethod(method)) {
      m_implementation=nullptr;
      std::vector<ConfigurationDatabaseImpl*>::iterator j;
      for (j=m_implementationOptions.begin(); j!=m_implementationOptions.end(); j++)
        if ((*j)->canHandleMethod(method)) {
          m_implementation=*j;
          break;
        }
    }

    if (m_implementation==nullptr)
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,toolbox::toString("Unable to open database using '%s'",accessor.c_str()));
    m_implementation->setLogger(m_logger);
    m_implementation->connect(accessor);

  }

  void ConfigurationDatabase::close() {
    if (m_implementation!=nullptr) m_implementation->disconnect();
  }

  unsigned int ConfigurationDatabase::getFirmwareChecksum(const std::string& board, unsigned int version) noexcept(false) {
    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    return m_implementation->getFirmwareChecksum(board,version);
  }

  ConfigurationDatabase::ApplicationConfig ConfigurationDatabase::getApplicationConfig(const std::string& tag, const std::string& classname, int instance) noexcept(false) {
    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }
    return m_implementation->getApplicationConfig(tag,classname,instance);

  }


  std::string ConfigurationDatabase::getConfigurationDocument(const std::string& tag) noexcept(false) {
    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }
    return m_implementation->getConfigurationDocument(tag);
  }

  void ConfigurationDatabase::getFirmwareMCS(const std::string& board, unsigned int version, std::vector<std::string>& mcsLines) noexcept(false) {
    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    m_implementation->getFirmwareMCS(board, version, mcsLines);

  }

  void ConfigurationDatabase::getLUTs(const std::string& tag, int crate, int slot, std::map<LUTId, LUT >& LUTs) noexcept(false) {

    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    std::map<unsigned int, std::string> results;

    m_implementation->getLUTs(tag, crate, slot, LUTs);

    if (LUTs.empty()) {
      XCEPT_RAISE(hcal::exception::ConfigurationItemNotFoundException,toolbox::toString("Not enough found (%d)",LUTs.size()));
    }
  }

  void ConfigurationDatabase::getLUTChecksums(const std::string& tag, std::map<LUTId, MD5Fingerprint>& checksums) noexcept(false) {
    checksums.clear();

    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    m_implementation->getLUTChecksums(tag, checksums);
  }

  void ConfigurationDatabase::getPatterns(const std::string& tag, int crate, int slot, std::map<PatternId, HTRPattern>& patterns) noexcept(false) {

    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    m_implementation->getPatterns(tag,crate,slot,patterns);

    if (patterns.empty()) {
      XCEPT_RAISE(hcal::exception::ConfigurationItemNotFoundException,toolbox::toString("Not found '$s',%d,%d",tag.c_str(),crate,slot));
    }
  }


  void ConfigurationDatabase::getRBXdata(const std::string& tag,
                     const std::string& rbx,
                     RBXdatumType dtype,
                     std::map<RBXdatumId, RBXdatum>& RBXdata)
    noexcept(false) {

    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    m_implementation->getRBXdata(tag,rbx,dtype,RBXdata);
  }

  void ConfigurationDatabase::getRBXpatterns(const std::string& tag,
                         const std::string& rbx,
                         std::map<RBXdatumId, RBXpattern>& patterns)
    noexcept(false) {

    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    m_implementation->getRBXpatterns(tag,rbx,patterns);
  }

  void ConfigurationDatabase::getZSThresholds(const std::string& tag, int crate, int slot, std::map<ZSChannelId, int>& thresholds)
    noexcept(false) {

    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    m_implementation->getZSThresholds(tag,crate,slot,thresholds);
  }

  void ConfigurationDatabase::getHLXMasks(const std::string& tag, int crate, int slot, std::map<FPGAId, HLXMasks>& m)
    noexcept(false) {

    if (m_implementation==nullptr) {
      XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database connection not open");
    }

    m_implementation->getHLXMasks(tag,crate,slot,m);
  }



  bool ConfigurationDatabase::FPGAId::operator<(const FPGAId& a) const {
    if (crate<a.crate) return true; 
    if (crate>a.crate) return false;
    if (slot<a.slot) return true; 
    if (slot>a.slot) return false;
    if (fpga<a.fpga) return true; 
    if (fpga>a.fpga) return false;
    return false; // equal is not less
  }
  bool ConfigurationDatabase::LUTId::operator<(const LUTId& a) const {
    if (crate<a.crate) return true; 
    if (crate>a.crate) return false;
    if (slot<a.slot) return true; 
    if (slot>a.slot) return false;
    if (fpga<a.fpga) return true; 
    if (fpga>a.fpga) return false;
    if (fiber_slb<a.fiber_slb) return true; 
    if (fiber_slb>a.fiber_slb) return false;
    if (channel<a.channel) return true; 
    if (channel>a.channel) return false;
    if (lut_type<a.lut_type) return true; 
    if (lut_type>a.lut_type) return false;
    return false; // equal is not less
  }
  bool ConfigurationDatabase::PatternId::operator<(const PatternId& a) const {
    if (crate<a.crate) return true; 
    if (crate>a.crate) return false;
    if (slot<a.slot) return true;
    if (slot>a.slot) return false;
    if (fpga<a.fpga) return true;
    if (fpga>a.fpga) return false;
    if (fiber<a.fiber) return true;
    if (fiber>a.fiber) return false;
    return false; // equal is not less
  }
  bool ConfigurationDatabase::ZSChannelId::operator<(const ZSChannelId& a) const {
    if (crate<a.crate) return true;
    if (crate>a.crate) return false;
    if (slot<a.slot) return true;
    if (slot>a.slot) return false;
    if (fpga<a.fpga) return true;
    if (fpga>a.fpga) return false;
    if (fiber<a.fiber) return true; 
    if (fiber>a.fiber) return false;
    if (channel<a.channel) return true; 
    if (channel>a.channel) return false;
    return false; // equal is not less
  }
  bool ConfigurationDatabase::RBXdatumId::operator<(const RBXdatumId& a) const {
    if (rm<a.rm) return true; 
    if (rm>a.rm) return false;
    if (card<a.card) return true; 
    if (card>a.card) return false;
    if (qie_or_gol<a.qie_or_gol) return true; 
    if (qie_or_gol>a.qie_or_gol) return false;
    if (dtype<a.dtype) return true; 
    if (dtype>a.dtype) return false;
    if (ltype<a.ltype) return true; 
    if (ltype>a.ltype) return false;
    return false; // equal is not less
  }

}