DetectorComponent.h

Go to the documentation of this file.

#ifndef _det_DetectorComponent_h_
#define _det_DetectorComponent_h_

#include <det/VManager.h>
#include <det/Detector.h>

#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/Validated.h>
#include <utl/VValidated.h>
#include <utl/ShadowPtr.h>

#include <sstream>
#include <vector>

#include <boost/utility.hpp>


namespace det {

  class Detector;


  template<class C>
  struct DetectorUserData {
    DetectorUserData(const std::string& /* mngrData */)
    { WARNING("Call to unspecialized DetectorUserData::DetectorUserData(const std::string&)."); }
  };


  template<class C, class ManagerProvider>
  class DetectorComponent : boost::noncopyable {
    // Aliases for container of managed fields.
    typedef std::vector<utl::VValidated*> FieldsContainer;

  public:
    int GetId() const { return fId; }

    const VManager::IndexMap& GetIdsMap() const { return fIdsMap; }

    std::string
    GetIdMessage()
      const
    {
      std::ostringstream o;
      AddIdMessage(o);
      return o.str();
    }

    const DetectorUserData<C>&
    GetUserData()
      const
    {
      if (!fUserData) {
        /*
         * XXX The user data the information has to
         * be stored as string in the managers:
         * there's no much point in making the managers and
         * branches to know the structure of the user data
         * because the idea is precisely to have something
         * customized with an unknown structure (until the
         * user provided an specization). Of course, some
         * refactoring could be put in the manager or branch
         * struture so as to call a specialized-user-data aware
         * method that could perform the loading given a branch.
         * By now, no changes in there and take the data to be
         * a string: which in the end is not something to bad
         * because at last what is read from the XML (and in the
         * end the only difference could be if the datum is
         * structured in several deeper branches).
         */
        // Temporal variable though which the data is loaded from the
        // managers.
        std::string dataMngr;
        // Returns the same object (or throws).
        GetDataNoWrap(dataMngr, "userData");
        // Once read, create the actual type datum, ...
        DetectorUserData<C>* const t = new DetectorUserData<C>();
        // call the static method that loads the data
        // (which can be "overrided" in a particular specialization) ...
        DetectorUserData<C>::Load(t, dataMngr);
        // and then make the field store the datum.
        fUserData = t;
      }
      return *fUserData;
    }

  protected:
    template<typename T, template<typename> class P>
    T& GetData(P<T>& d, const std::string& p) const { return GetDataUnwrap<T>(d, p); }

    template<typename T1, typename T2, template<typename,typename> class P>
    T1&
    GetData(P<T1, T2>& d, const std::string& p)
      const
    {
      // In utl::ShadowPtr the 1st the is still the datum data-type, the 2nd
      // is the policy.
      return GetDataUnwrap<T1>(d, p);
    }

    template<typename T>
    T&
    GetData(utl::Validated<T>& d, const std::string& p)
      const
    {
      if (! d.IsValid()) {
        GetDataNoWrap(d.Get(), p);
        d.SetValid();
      }
      return d.Get();
    }

    template<typename T>
    T& GetData(T& d, const std::string& p) const { return GetDataNoWrap(d, p); }

    void
    AddIdMessage(std::ostringstream& s)
      const
    {
      typedef det::VManager::IndexMap::const_iterator It;
      // Put the self id...
      s << "id=" << GetId() << " [";
      // and then the id map.
      // TODO There's no definite order.
      for (It i = GetIdsMap().begin(), e = GetIdsMap().end(); i != e; ++i)
        s << " " << i->first << "=" << i->second;
      s << " ]";
    }

    DetectorComponent(int i, const VManager::IndexMap& parentMap)
      : fId(i), fIdsMap(parentMap) { Init(); }

    DetectorComponent(const int i) : fId(i) { Init(); }

    virtual ~DetectorComponent() { }

    virtual
    void
    Update(const bool invalidateData, const bool /*invalidateComponents*/)
    {
      if (invalidateData)
        for (FieldsContainer::iterator i = fFields.begin(), e = fFields.end(); i != e; ++i)
          (*i)->SetValid(false);
    }

    void Register(utl::VValidated& v) { fFields.push_back(&v); }

  private:
    template<typename T>
    T&
    GetDataNoWrap(T& d, const std::string& p)
      const
    {
      // A datum needs to be retrieved.
      const VManager& mngr = ManagerProvider::GetInstance();
      // Pass a reference to the datum.
      const VManager::Status f = mngr.GetData(d, p, C::kComponentName, fIdsMap);
      if (f == VManager::eNotFound) {
        std::ostringstream err;
        err << "Did not find the requested component: '"
            << p << "' in " << GetIdMessage() << ".";
        ERROR(err);
        throw utl::NonExistentComponentException(err.str());
      }
      //DEBUGLOG(BuildLogMessage(d, p, std::string(C::kComponentName)/*, fIdsMap*/));
      return d;
    }

    template<typename R, typename T>
    R&
    GetDataUnwrap(T& d , const std::string& p)
      const
    {
      if (!d) {
        // Heap allocate the datum ...
        R* const t = new R();
        // and pass the pointer to d in order to get it handled by it.
        d = t;
        // Call the non-wrapped version, with a reference (thanks to *)
        // to the datum.
        return GetDataNoWrap(*t, p);
      }
      return *d;
    }

    template<typename T>
    //static
    std::string
    BuildLogMessage(const T& d, const std::string& p, const std::string& c/*, const VManager::IndexMap& m*/)
    {
      std::ostringstream s;
      s << c << ", " << p << " in " << GetIdMessage() << " with data= " << d;
      return s.str();
    }

    template<typename T>
    //static
    std::string
    BuildLogMessage(const std::list<T>& d, const std::string& p, const std::string& c/*, const VManager::IndexMap& m*/)
    {
      // Fake datum, it's an string indicating the list list values (don't want to overload << for lists).
      std::ostringstream s;
      s << '{';
      for (typename std::list<T>::const_iterator i = d.begin(); i != d.end(); ++i)
        s << (*i) << ' '; // Not any delimiters between positions.
      s << '}';
      return BuildLogMessage(s.str(), p, c/*, m*/);
    }

    void
    Init()
    {
      // Add this component's id to map that
      // comes as a copy from this component's
      // parent
      std::ostringstream idStr;
      idStr << GetId();
      // Add to the map, using the template argument
      // to obtain the key.
      fIdsMap[C::kComponentId] = idStr.str();
    }

    int fId;

    VManager::IndexMap fIdsMap;

    FieldsContainer fFields;

    mutable utl::ShadowPtr<DetectorUserData<C> > fUserData;
};

}

#endif