ManagerRegister.h

Go to the documentation of this file.

#ifndef _sdet_ManagerRegister_h_
#define _sdet_ManagerRegister_h_

#include <list>
#include <sstream>
#include <string>
#include <map>
#include <boost/iterator/indirect_iterator.hpp>
#include <det/VManager.h>
#include <utl/ErrorLogger.h>


namespace utl {
  class Reader;
  class Branch;
}

namespace det {

  class VManagerBuilder;


  class ManagerRegister : public det::VManager {

  private:
    typedef std::vector<VManager*> ManagerCollection;
    typedef ManagerCollection::const_iterator InternalManagerIterator;

  public:
    ManagerRegister(const std::string& name)
      : VManager(name) { }

    virtual ~ManagerRegister() { }

    // The individual managers are automatically initialized during configuration
    virtual void Init(const std::string&) { }

    // NOTE ON CONFIGURE METHODS:  These methods were introduced in anticipation
    // of providing a way to reconfigure the detector managers on-the-fly.  It
    // has not yet (as of 22/6/03) been decided to what extent this reconfiguration
    // cabability will be provided.  We may allow reconfiguration at any time,
    // only during construction of the Detector, or never  -- depending on which
    // of these 3 approches is chosen to be be the best, the Configure methods
    // below may be modified accordingly.  eg. if only configured upon detector
    // construction, should the Configure methods be public  (if so, users could
    // reconfigure the detector) ?  It may be okay to
    // leave them as public since  users are not supposed to interact directly
    // with the ManagerRegister anyway.


    void Configure(const utl::Branch branch);


    void Configure(const std::ostringstream& configInstructions);

    typedef boost::indirect_iterator<InternalManagerIterator,
                                     VManager&> ManagerIterator;

    ManagerIterator ManagersBegin() const
    { return ManagerIterator(fConfiguredManagerList.begin()); }

    ManagerIterator ManagersEnd() const
    { return ManagerIterator(fConfiguredManagerList.end()); }

    /*
     * RFG 20091007 Originally this method was non-const, tough
     * it should be (and can be), so we made it const; the real reason
     * for this is to be able to introduce a non-const version (on the
     * return type also, of course).
     */
    const VManager& GetManager(const std::string& managerName) const;

    /*
      RFG 20091007

      Caveat Emptor: Since the VManager is returning non-const, take care
      to use it properly. For instance, it may not be possible (in the
      sense right behaviour) to modify the name of the VManager (incidentally
      it is right because the look-up by name is peformed here in a linear search
      over the managers themselves, instead of performing a look-up on an
      associative structure -like std::map - having a copy of the (original)
      name as key).

      At last, let's state this: non-const methods from VManager itself
      shouldn't be called, and instead call (though casting) whatever method
      a particular manager provides.

      This ended being used in MdOverrideManagerAG::MdOverrideManager, so as to
      be able to call its det::XXMLManager::NextConfiguration. Of course,
      the field modified in that method could be made mutable, but I'd that's
      cheating because the field is no cache-like or so.
     */
    VManager& GetManager(const std::string& managerName);

    // data getters implementing VManager interface

#define MANAGERREGISTER_GETDATA(_T_...)                  \
    Status GetData(_T_& returnData,                      \
                   const std::string& componentProperty, \
                   const std::string& componentName,     \
                   const IndexMap& componentIndex) const \
    { return GetManagerData(returnData, componentProperty, componentName, componentIndex); }

    MANAGERREGISTER_GETDATA(double)
    MANAGERREGISTER_GETDATA(int)
    //MANAGERREGISTER_GETDATA(unsigned long long int)
    MANAGERREGISTER_GETDATA(std::string)
    MANAGERREGISTER_GETDATA(std::vector<double>)
    MANAGERREGISTER_GETDATA(std::vector<int>)
    MANAGERREGISTER_GETDATA(std::vector<std::string>)
    MANAGERREGISTER_GETDATA(std::vector<bool>)
    MANAGERREGISTER_GETDATA(std::list<double>)
    MANAGERREGISTER_GETDATA(std::list<int>)
    MANAGERREGISTER_GETDATA(std::list<std::string>)
    MANAGERREGISTER_GETDATA(utl::TabulatedFunction)
    MANAGERREGISTER_GETDATA(utl::TabulatedFunctionComplexLgAmpPhase)
    MANAGERREGISTER_GETDATA(std::list<std::pair<int, int> >)
    MANAGERREGISTER_GETDATA(std::map<int, utl::TabulatedFunction>)
    MANAGERREGISTER_GETDATA(std::vector<std::vector<int> >)
    MANAGERREGISTER_GETDATA(std::map<std::string, double>)
#undef MANAGERREGISTER_GETDATA

    template<typename T>
    Status
    GetData(T& returnData,
            const std::string& component,
            const std::string& property,
            const IndexMap& componentIndex = IndexMap())
      const
    {
      Handle handle(returnData);
      return GenericGetData(handle, component, property, componentIndex);
    }

    template<typename T>
    Status
    GetDataOrThrow(T& returnData,
                   const std::string& component,
                   const std::string& property,
                   const IndexMap& index = IndexMap())
      const
    {
      Handle handle(returnData);
      const Status status = GenericGetData(handle, component, property, index);
      if (status == VManager::eNotFound)
        NotFoundAndThrow(handle, component, property, index);
      return status;
    }

  private:
    void RegisterBuilder(const std::string& name, VManagerBuilder& builder);

    typedef std::map<std::string, VManagerBuilder*> ManagerBuilderMap;
    ManagerBuilderMap fManagerBuilderRegister;

    ManagerCollection fConfiguredManagerList;

    void InterpretXML(const utl::Branch& topBranch);

    std::string GetConfiguredManagerListString() const;

    template<typename T>
    Status
    GetManagerData(T& returnData,
                   const std::string& componentProperty,
                   const std::string& componentName,
                   const IndexMap& componentIndex)
      const
    {
      bool seenOne = false;
      for (ManagerIterator it = ManagersBegin(); it != ManagersEnd(); ++it) {
        seenOne = true;
        const Status status =
          it->GetData(returnData, componentProperty, componentName, componentIndex);
        if (status == eFound)
          return eFound;
      }
      // try again with reporting errors
      if (FindComponent<bool>("reportErrors", true, componentIndex)) {
        if (seenOne) {
          std::ostringstream warn;
          warn << "None of the managers (" << GetConfiguredManagerListString()
               << ") in " << GetName() << " found "
               << QueryInfoMessage(componentProperty, componentName, componentIndex)
               << " data. Trying to figure out the reason why...";
          WARNING(warn);
          for (ManagerIterator it = ManagersBegin(); it != ManagersEnd(); ++it) {
            it->SetReportingErrors(true);
            it->GetData(returnData, componentProperty, componentName, componentIndex);
            it->SetReportingErrors(false);
          }
        } else
          WARNING(std::string("No managers in ") + GetName() + " to get " +
                  QueryInfoMessage(componentProperty, componentName) + " data.");
      }

      return eNotFound;
    }

    virtual
    Status
    GenericGetData(Handle& returnData,
                   const std::string& component,
                   const std::string& property,
                   const IndexMap& componentIndex)
      const
    {
      bool seenOne = false;
      for (ManagerIterator it = ManagersBegin(); it != ManagersEnd(); ++it) {
        seenOne = true;
        const Status status =
          it->GetData(returnData, component, property, componentIndex);
        if (status == eFound)
          return eFound;
      }
      // try again with reporting errors
      if (FindComponent<bool>("reportErrors", true, componentIndex)) {
        if (seenOne) {
          std::ostringstream warn;
          warn << "None of the managers (" << GetConfiguredManagerListString()
               << ") in " << GetName() << " found "
               << QueryInfoMessage(returnData, component, property, componentIndex)
               << " data. Trying to figure out the reason why...";
          WARNING(warn);
          for (ManagerIterator it = ManagersBegin(); it != ManagersEnd(); ++it) {
            it->SetReportingErrors(true);
            it->GetData(returnData, component, property, componentIndex);
            it->SetReportingErrors(false);
          }
        } else
          WARNING(std::string("No managers in ") + GetName() + " to get " +
                  QueryInfoMessage(returnData, component, property, componentIndex) +
                  " data.");
      }

      return eNotFound;
    }

    static void NotFoundAndThrow(const Handle& handle,
                                 const std::string& component, const std::string& property,
                                 const IndexMap& index);

    friend class ManagerBuilderRegisterEntry;

  };


} // namespace det


#endif // det_ManagerRegister_h_

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: