ManagerRegister.cc

Go to the documentation of this file.

#include <det/VManagerBuilder.h>
#include <utl/ErrorLogger.h>
#include <utl/Reader.h>
#include <utl/String.h>
#include <utl/AugerException.h>
#include <det/ManagerRegister.h>

using namespace std;
using namespace utl;


namespace det {

void
ManagerRegister::Configure(const Branch branch)
{
  InterpretXML(branch);
}


void
ManagerRegister::Configure(const ostringstream& configInstructions)
{
  const ReaderStringInput readerInput(configInstructions);
  Reader reader(readerInput);
  const Branch topB = reader.GetTopBranch();
  InterpretXML(topB);
}


void
ManagerRegister::InterpretXML(const Branch& topB)
{
  fConfiguredManagerList.clear();

  for (Branch managerB = topB.GetFirstChild(); managerB;
       managerB = managerB.GetNextSibling()) {

    if (managerB.GetName() != "manager")
      throw XMLParseException("Malformed manager specification, should be <manager>!");

    string managerName;
    managerB.GetData(managerName);

    if (fManagerBuilderRegister.empty()) {
      ostringstream err;
      err << "Unable to create manager " << managerName << " "
             "since the list of manager builders is empty.";
      throw XMLParseException(err.str());
    }

    const ManagerBuilderMap::const_iterator mIt =
      fManagerBuilderRegister.find(managerName);

    if (mIt == fManagerBuilderRegister.end()) {

      ostringstream err;
      err << "The requested manager builder '" << managerName << "' does not exist. "
             "Available manager builders: " << String::OfMapKeys(fManagerBuilderRegister);
      throw XMLParseException(err.str());

    } else {

      VManagerBuilder* const managerBuilder = mIt->second;
      VManager& manager = managerBuilder->GetManager();
      // Initialize the manager
      // Note that the configLink must be the manager name,
      // as defined during the manager construction in the Detector singleton
      manager.SetName(managerName);
      manager.Init(managerName);
      if (manager.IsInitialized())
        fConfiguredManagerList.push_back(&manager);
      else {
        ostringstream warn;
        warn << "Manager '" << managerName << "' failed to initialize properly!";
        WARNING(warn);
      }

    }

  }
}

VManager&
ManagerRegister::GetManager(const string& managerName) 
{
  // Regarding all this circumlocution see det::ComponentGroup::Get(int id).
  return const_cast<VManager&>(static_cast<const ManagerRegister&>(*this).GetManager(managerName));
}



const VManager&
ManagerRegister::GetManager(const string& managerName)
const
{
  if (fConfiguredManagerList.empty()) {
    ostringstream err;
    err << "List of initialized managers in '" << GetName() << " is empty.";
    throw NonExistentComponentException(err.str());
  }

  for (ManagerIterator it = ManagersBegin(); it != ManagersEnd(); ++it)
    if (it->GetName() == managerName)
      return *it;

  ostringstream err;
  err << "The requested manager '" << managerName
      << "' does not exist or is not initialized. "
         "Available managers: " << GetConfiguredManagerListString();
  throw NonExistentComponentException(err.str());
}


void
ManagerRegister::RegisterBuilder(const string& name, VManagerBuilder& builder)
{
  if (fManagerBuilderRegister.find(name) != fManagerBuilderRegister.end()) {
    ostringstream warn;
    warn << "Attempt to register more than one manager builder for manager with "
            "name '" << name << "'. Only the last registered manager builder will be used!";
    WARNING(warn);
  }

  fManagerBuilderRegister.insert(make_pair(name, &builder));
}


string
ManagerRegister::GetConfiguredManagerListString()
  const
{
  if (fConfiguredManagerList.empty())
    return "";

  ostringstream managers;
  ManagerIterator it = ManagersBegin();
  managers << it->GetName();
  for (++it; it != ManagersEnd(); ++it)
    managers << ", " << it->GetName();

  return managers.str();
}


// static
void
ManagerRegister::NotFoundAndThrow(const Handle& returnData,
                                  const string& component,
                                  const string& property,
                                  const IndexMap& index)
{
  ostringstream err;
  err << "Get data failure for "
      << QueryInfoMessage(returnData, component, property, index);
  ERROR(err);
  throw NonExistentComponentException(err.str());
}

}