ConfigurationInterface.cpp

#include "ConfigurationInterface.h"
#include "Sct/SctNames.h"
#include "Sct/IoExceptions.h"
#include "Sct/StdExceptionWrapper.h"
#include "Sct/ConfigurationException.h"
#include <iomanip>
#include <is/info.h>
#include <is/infodictionary.h>
#include <is/infoiterator.h>
#include <is/inforeceiver.h>
#include <is/infoT.h>

using namespace SctConfiguration;

namespace SctAnalysis{

ConfigurationInterface::ConfigurationInterface(boost::shared_ptr<Configuration> c) : m_config(c)
{
  m_infoReceiver = boost::shared_ptr<ISInfoReceiver>(new ISInfoReceiver(Sct::SctNames::getPartition()));
  m_infoReceiver->subscribe("ConfigurationServer", "SystemStructureChangeCount", updateCallback, this);
  m_infoReceiver->subscribe("ConfigurationServer", "ModuleMappingChangeCount", updateCallback, this);
}

ConfigurationInterface::~ConfigurationInterface(){
}

std::string ConfigurationInterface::getDcsId(const std::string& modulename) const {
  //std::cout << "ConfigurationInterface getDcsId " << modulename << std::endl;
  std::map<std::string, std::string>::const_iterator it = m_map.find(modulename );
  if (it==m_map.end()) { 
    //std::cout << "(none)" << std::endl;
    return "";
  } else {
    //std::cout << "`" << (*it).second << "'" << std::endl;
    return (*it).second;
  }
}

bool ConfigurationInterface::empty() const{
  return m_map.empty();
}

void ConfigurationInterface::update(){
  boost::recursive_mutex::scoped_lock lock(m_access);
  m_map.clear();
  std::list<std::string> modules;
  try{
    modules = m_config->listAllModules();
  }catch(Sct::Throwable& e){
    Sct::ConfigurationException("Error getting power mappings", e, __FILE__, __LINE__).sendToMrs(MRS_INFORMATION);
  }catch(SctConfiguration::ConfigurationException& e){
    std::ostringstream oss;
    oss << "Error getting power mappings " << e.what();
    Sct::ConfigurationException(oss.str(), __FILE__, __LINE__).sendToMrs(MRS_INFORMATION);
  }catch(std::exception& e){
    Sct::StdExceptionWrapper err(e);
    Sct::ConfigurationException("Error getting power mappings", err, __FILE__, __LINE__).sendToMrs(MRS_INFORMATION);
  }
  
  unsigned nprob=0;
  for (std::list<std::string>::const_iterator i=modules.begin(); i!= modules.end(); ++i){
    unsigned crate, channel, partition, mur, mod;
    try{
      m_config->translateFromSN(*i, mur, mod);
      m_config->translateToPowerSupply(mur, mod, partition, crate, channel);
      m_map[*i]=encode(partition, crate, channel);
      std::cout << "Mapped module " << *i << " to " << encode(partition, crate, channel) << std::endl;
    }catch(SctConfiguration::ConfigurationException& e){
      if (nprob<10) std::cerr << e.what() << std::endl;
      if (nprob==0) std::cerr << "[No more error messages will be printed for this update]" << std::endl;
      nprob++;
    }
  }
  print(std::cout);
}

std::string ConfigurationInterface::encode(unsigned partition, unsigned crate, unsigned channel){
  std::ostringstream oss;
  oss << "Crate" << std::setw(2) << std::setfill('0') << crate 
      << ".Channel" << std::setw(2) << std::setfill('0') << channel;
  return oss.str();
}

void ConfigurationInterface::print(std::ostream& os) const{
  boost::recursive_mutex::scoped_lock lock(m_access);
  std::cout << "ConfigurationInterface::print" << std::endl;
  os << "Configuration Interface has power maps for " 
     << m_map.size() << " modules" << std::endl;
}

void ConfigurationInterface::updateCallback(ISCallbackInfo* isc){
  if (isc->reason() == is::Created || isc->reason() == is::Updated ){
    ConfigurationInterface* rock=static_cast<ConfigurationInterface*>(isc->parameter());
    rock->update();
  }
}

}

---