VManager.h

Go to the documentation of this file.

#ifndef _det_VManager_h_
#define _det_VManager_h_

#include <string>
#include <set>
#include <vector>
#include <list>
#include <map>
#include <boost/lexical_cast.hpp>
#include <utl/TabulatedFunction.h>
#include <utl/TabulatedFunctionComplexLgAmpPhase.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/Reader.h>
#include <utl/TypeId.h>


/* Use this macro for derived-manager GetData() methods that should never
   be called. They will instantly issue an error message */

#define VMANAGER_GETDATA_DENIED(_T_...)                                   \
  virtual                                                                 \
  Status                                                                  \
  GetData(_T_&,                                                           \
          const std::string& componentProperty,                           \
          const std::string& componentName,                               \
          const VManager::IndexMap&)                                      \
    const                                                                 \
  {                                                                       \
    ERROR(NotImplementedMessage(#_T_, componentProperty, componentName)); \
    return eNotFound;                                                     \
  }


/* Use this macro for derived-manager GetData() methods that do not support
   the specific parameter, but it is OK to check the rest of the managers in
   the ManagerRegister chain. They will issue an error message in the
   second run, when none of the other managers finds data, and the request
   is repeated with IsReportingErrors() switched on. */

#define VMANAGER_GETDATA_NOTFOUND(_T_...)                                   \
  virtual                                                                   \
  Status                                                                    \
  GetData(_T_&,                                                             \
          const std::string& componentProperty,                             \
          const std::string& componentName,                                 \
          const VManager::IndexMap&)                                        \
    const                                                                   \
  {                                                                         \
    if (IsReportingErrors())                                                \
      ERROR(NotImplementedMessage(#_T_, componentProperty, componentName)); \
    return eNotFound;                                                       \
  }


/* Use this macro if you want to reroute call to some other method (usually a
   template */

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


/* Use this macro to declare the overriding method in derived managers. */

#define VMANAGER_GETDATA_DECLARE(_T_...)                         \
  Status GetData(_T_& returnData,                                \
                 const std::string& componentProperty,           \
                 const std::string& componentName,               \
                 const VManager::IndexMap& componentIndex) const;

#define VMANAGER_GETDATA_HANDLE_DENIED                                             \
  virtual                                                                          \
  Status                                                                           \
  GenericGetData(VManager::Handle& returnData,                                     \
                 const std::string& component,                                     \
                 const std::string& property,                                      \
                 const VManager::IndexMap&)                                        \
    const                                                                          \
  {                                                                                \
    ERROR(NotImplementedMessage(returnData.GetTypeIdName(), component, property)); \
    return eNotFound;                                                              \
  }


namespace det {

  class VManager {
  public:
    VManager() { }

    VManager(const std::string& name) : fName(name) { }

    virtual ~VManager() { }


    enum Status {
      eFound,
      eNotFound
    };

    // component index map
    typedef std::map<std::string, std::string> IndexMap;

    class Handle {
    public:
      template<typename T>
      explicit Handle(T& t) : fData(&t), fTypeIdMangledName(utl::TypeId::MangledName<T>()) { }

      // this could be all compiler generated but is explicitly implemented in order to show intent
      ~Handle() { }
      Handle(const Handle& h) : fData(h.fData), fTypeIdMangledName(h.fTypeIdMangledName) { }
      Handle& operator=(const Handle& h)
      { fData = h.fData; fTypeIdMangledName = h.fTypeIdMangledName; return *this; }

      template<typename T>
      typename boost::add_reference<typename boost::remove_const<T>::type>::type Get()
      { Check<T>(); return *static_cast<typename boost::add_pointer<typename boost::remove_const<T>::type>::type>(fData); }

      template<typename T>
      typename boost::add_reference<typename boost::add_const<T>::type>::type Get() const
      { Check<T>(); return *static_cast<typename boost::add_pointer<typename boost::add_const<T>::type>::type>(fData); }

      std::string GetTypeIdName() const { return utl::TypeId::Demangle(fTypeIdMangledName); }

      const std::string& GetTypeIdMangledName() const { return fTypeIdMangledName; }

      template<typename T>
      bool Is() const { return fTypeIdMangledName == utl::TypeId::MangledName<T>(); }

    private:
      template<typename T>
      void
      Check()
        const
      {
        if (!Is<T>()) {
          std::ostringstream os;
          os << "cannot Handle(" << GetTypeIdName() << ").Get<" << utl::TypeId::Name<T>() << ">()";
          ERROR(os);
          throw utl::DoesNotComputeException(os.str());
        }
      }

      void* fData = nullptr;
      std::string fTypeIdMangledName;
    };


    virtual void Init(const std::string& configLink);

    bool IsInitialized() const { return fIsInitialized; }


    void SetReportingErrors(const bool flag = true) { fReportingErrors = flag; }

#define VMANAGER_ABSTRACT_GETDATA(_T_...)                        \
    virtual Status GetData(_T_& returnData,                      \
                           const std::string& componentProperty, \
                           const std::string& componentName,     \
                           const IndexMap& componentIndex) const = 0

    VMANAGER_ABSTRACT_GETDATA(double);
    VMANAGER_ABSTRACT_GETDATA(int);
    VMANAGER_GETDATA_DENIED(bool);
    VMANAGER_ABSTRACT_GETDATA(std::string);
    VMANAGER_ABSTRACT_GETDATA(std::vector<double>);
    VMANAGER_ABSTRACT_GETDATA(std::vector<int>);
    VMANAGER_ABSTRACT_GETDATA(std::vector<std::string>);
    VMANAGER_ABSTRACT_GETDATA(std::vector<bool>);
    VMANAGER_ABSTRACT_GETDATA(std::list<double>);
    VMANAGER_ABSTRACT_GETDATA(std::list<int>);
    VMANAGER_ABSTRACT_GETDATA(std::list<std::string>);
    VMANAGER_ABSTRACT_GETDATA(std::list<std::pair<int, int>>);
    VMANAGER_ABSTRACT_GETDATA(utl::TabulatedFunction);
    VMANAGER_ABSTRACT_GETDATA(std::map<int, utl::TabulatedFunction>);
    VMANAGER_ABSTRACT_GETDATA(utl::TabulatedFunctionComplexLgAmpPhase);
    VMANAGER_ABSTRACT_GETDATA(std::map<std::string, double>);
    VMANAGER_GETDATA_DENIED(std::vector<std::vector<int>>);
    VMANAGER_GETDATA_DENIED(std::map<unsigned int, int>);

#undef VMANAGER_ABSTRACT_GETDATA


    Status
    GetData(Handle& returnData,
            const std::string& component,
            const std::string& property,
            const IndexMap& index = IndexMap())
      const
    {
      return CheckedGetData(returnData, component, property, index);
    }

    static std::string QueryInfoMessage(const Handle& returnData,
                                        const std::string& component);

    static std::string QueryInfoMessage(const Handle& returnData,
                                        const std::string& component,
                                        const std::string& property,
                                        const IndexMap& index);

    static
    std::string
    QueryInfoMessage(const std::string& componentProperty,
                     const std::string& componentName)
    {
      return std::string("('") + componentProperty + "', '" + componentName + "')";
    }

    static std::string QueryInfoMessage(const std::string& componentProperty,
                                        const std::string& componentName,
                                        const IndexMap& componentIndex);

    template<typename T>
    static
    T
    FindComponent(const std::string& componentName, const IndexMap& componentIndex)
    {
      const IndexMap::const_iterator it = componentIndex.find(componentName);
      if (it == componentIndex.end()) {
        std::ostringstream err;
        err << "component " << componentName << " not found!";
        ERROR(err);
        throw utl::NonExistentComponentException(err.str());
      }
      return boost::lexical_cast<T>(it->second);
    }

    template<typename T, typename U>
    static
    T
    FindComponent(const std::string& componentName, const U& defaultValue,
                  const IndexMap& componentIndex)
    {
      const IndexMap::const_iterator it = componentIndex.find(componentName);
      return (it == componentIndex.end()) ?
        boost::lexical_cast<T>(defaultValue) : boost::lexical_cast<T>(it->second);
    }

    const std::string& GetName() const { return fName; }

    void SetName(const std::string& name) { fName = name; }

  protected:
    void FindConfig(const std::string& configLink);

    bool IsReportingErrors() const { return fReportingErrors; }

    std::string
    NotImplementedMessage(const std::string& type,
                          const std::string& componentProperty,
                          const std::string& componentName) const;

    template<typename T>
    void
    AddAvailability(const std::string& component)
    {
      AddAvailability(utl::TypeId::Name<T>(), component);
    }

    // Flag the Manager as initialized. (It is initialized if
    // it successfully found its data source.)
    mutable bool fIsInitialized = false;

    bool fReportingErrors = false;

    // Configuration file reader
    // do not delete in dtor
    utl::Branch fBranch;

    std::set<std::string> fAvailableComponents;

  private:
    void AddAvailability(const std::string& typeIdName, const std::string& component)
    { fAvailability[typeIdName].insert(component); }

    bool CanAnswer(const Handle& returnData, const std::string& component) const;

    Status
    CheckedGetData(Handle& returnData,
                   const std::string& component,
                   const std::string& property,
                   const IndexMap& index)
      const
    {
      if (CanAnswer(returnData, component)) {
        const Status status =
          GenericGetData(returnData, component, property, index);
        if (status == eFound)
          return eFound;
        else if (IsReportingErrors())
          WARNING(std::string("Manager ") + GetName() + " did not find " +
                  QueryInfoMessage(returnData, component));
      }
      return eNotFound;
    }

    virtual
    Status
    GenericGetData(Handle& returnData,
                   const std::string& component,
                   const std::string& property,
                   const IndexMap& index) const = 0;

    std::string fName;

    typedef std::set<std::string> ComponentSet;
    typedef std::map<std::string, ComponentSet> AvailabilityMap;
    AvailabilityMap fAvailability;

  };

}


#endif