Detector/ComponentGroup.h

Go to the documentation of this file.

#ifndef _det_ComponentGroup_h
#define _det_ComponentGroup_h

#include <det/VManager.h>
#include <det/DetectorComponent.h>
#include <utl/ErrorLogger.h>
//
#include <list>
#include <set>
#include <algorithm>
//
// This include generates a warning:
// boost/ptr_container/detail/map_iterator.hpp:52: warning: type qualifiers ignored on function return type
// https://svn.boost.org/trac/boost/ticket/4276
#include <boost/ptr_container/ptr_map.hpp>
#include <boost/iterator/transform_iterator.hpp>


namespace det {

  struct IdOnlyCreator {
    template<class Parent, class Child>
    static Child* CreateObject(int id, const Parent& /*parent*/)
    { return new Child(id); }
  };


  struct ParentCreator {
    template<class Parent, class Child>
    static Child* CreateObject(int id, const Parent& parent)
    { /* Retrieve the parent's ids. */ return new Child(id, parent.GetIdsMap(), parent); }
  };


  struct ComponentUpdater {
  private:
    template<class A1, class A2, class A3, class A4> friend class ComponentGroup;

    template<class Component>
    static void UpdateComponent(Component& c, bool invData, bool invComp)
    { c.Update(invData, invComp); }
  };


  template<class P, class C, class Creator, class ManagerProvider>
  class ComponentGroup {
  private:
    typedef boost::ptr_map<int, C> ComponentMap;

    /*
     * It seems that's more proper to have a set here; but VManager
     * doesn't set methods. Anyway this class doesn't rely on a no-repetitions
     * invariant; having them will only degrade the performance and it's
     * meaningless (this class only care about membership).
     * See next.
     */
    typedef std::list<int> IdList;

    /*
     * Now we may want to query, repeteadly the existance of a given component,
     * without actually loading the component. For this case, we fill a set
     * so as to have an efficient query mechanism (instead of a linear search
     * along the list). Note that, obviously, any repetition in the list is lost,
     * which is 0k.
     */
    typedef std::set<int> IdSet;
    typedef typename IdList::const_iterator IdIterator;
    typedef typename ComponentMap::iterator ComponentMapIterator;
    typedef typename ComponentMap::const_iterator ComponentMapConstIterator;

    struct InternalConstFunctor {
      InternalConstFunctor(const ComponentGroup<P, C, Creator, ManagerProvider>& p)
        : fContainer(p) { }
      const C& operator()(const IdList::value_type& id) const
      { return fContainer.Get(id); }
    private:
      const ComponentGroup<P, C, Creator, ManagerProvider>& fContainer;
    };

    struct InternalFunctor {
      InternalFunctor(ComponentGroup<P, C, Creator, ManagerProvider>& p)
        : fContainer(p) { }

      C& operator()(const IdList::value_type& id) const
      { return fContainer.Get(id); }

    private:
      ComponentGroup<P, C, Creator, ManagerProvider>& fContainer;
    };

  public:
    typedef boost::transform_iterator<
      InternalConstFunctor,
      IdIterator,
      const C&
    > ConstIterator;

    typedef boost::transform_iterator<
      InternalFunctor,
      IdIterator,
      C&
    > Iterator;

    typedef C ComponentType;

    ComponentGroup(const P& p) : fParent(p) { }

    const C& Get(int i) const;

    C& Get(int i);

    bool Exists(int i) const;

    ConstIterator
    Begin()
      const
    {
      // Here the call is 'begin' in lower case as of standard-C++ usage.
      return ConstIterator(fComponentsIds.begin(), InternalConstFunctor(*this));
    }

    ConstIterator
    End()
      const
    {
      // see Begin().
      return ConstIterator(fComponentsIds.end(), InternalConstFunctor(*this));
    }

    Iterator
      Begin()
    {
      // See const Begin.
      return Iterator(fComponentsIds.begin(), InternalFunctor(*this));
    }

    Iterator
    End()
    {
      // see Begin().
      return Iterator(fComponentsIds.end(), InternalFunctor(*this));
    }

    void Update(const VManager::IndexMap& m, const bool invalidateData = true, const bool invalidateComponents = true);

    typedef IdList::size_type SizeType;

    SizeType GetNumberOfComponents() const { return fNumberOfIds; }

  private:
    const P& fParent;

    mutable ComponentMap fComponentsById;

    mutable IdList fComponentsIds;

    mutable SizeType fNumberOfIds;

    mutable IdSet fComponentsIdsSet;
  };


  template<class P, class C, class Creator, class ManagerProvider>
  void
  ComponentGroup<P, C, Creator, ManagerProvider>::Update(const VManager::IndexMap& m, const bool invalidateData, const bool invalidateComponents)
  {
    //DEBUGLOG("Updating");
    // Check for empty as an indicator that this is the first call to update.
    if (fComponentsIds.empty() || invalidateComponents) {
      // Clear all as part of component invalidation...
      fComponentsIds.clear();
      fComponentsById.clear();
      fComponentsIdsSet.clear();
      fNumberOfIds = 0;
      // This update method seems to be an implicit interface for Detectors.
      // Keep its name within this template class, but with an aditional
      // parameter: the map.
      // --
      // Retrieve the manager via the template argument.
      const VManager& mgr = ManagerProvider::GetInstance();
      // Rely on the field with the name.
      const VManager::Status s = mgr.GetData(fComponentsIds, C::kComponentName, "", m);
      if (s == VManager::eNotFound) {
        std::ostringstream e;
        e << "Couldn't find the list of " << C::kComponentName << ':';
        for (VManager::IndexMap::const_iterator i = m.begin(); i != m.end(); ++i) {
          e << ' ' << i->first << '=' << i->second;
        }
        //DEBUGLOG(e);
      } else {
        // std::list::size has linear behaviour.
        fNumberOfIds = fComponentsIds.size();
      }
    }
    /*
     * Now update (only) the components already loaded (this may be
     * a second call to the Update method).
     */
    for (ComponentMapIterator i = fComponentsById.begin(), e = fComponentsById.end(); i != e; ++i)
      ComponentUpdater::UpdateComponent(*(i->second), invalidateData, invalidateComponents);
    //DEBUGLOG("Updating end");
  }


  template<class P, class C, class Creator, class ManagerProvider>
  const C&
  ComponentGroup<P, C, Creator, ManagerProvider>::Get(int id)
    const
  {
    // Look for already created objects.
    const ComponentMapConstIterator ic = fComponentsById.find(id);
    if (ic != fComponentsById.end())
      return *ic->second;
    // Need to load him, if it exists: modify internal mutable data fields.
    const IdIterator ii = std::find(fComponentsIds.begin(), fComponentsIds.end(), id);
    if (ii != fComponentsIds.end()) {
      // Being a template functions eases the use & specalization, but puts the burden
      // in this call.
      C* c = Creator::template CreateObject<P, C>(id, fParent);
      fComponentsById.insert(id, c);
      return *c;
    } else {
      std::ostringstream e;
      e << "No " << C::kComponentName << " with Id= " << id << " was found.";
      ERROR(e);
      throw utl::NonExistentComponentException(e.str());
    }
  }


  template<class P, class C, class Creator, class ManagerProvider>
  C&
  ComponentGroup<P, C, Creator, ManagerProvider>::Get(int id)
  {
    /*
     * Use const_cast s to avoid repetition as recommended in
     * "Avoid Duplication in const and Non-const Member Function," on p. 23, in Item 3
     * "Use const whenever possible," in Effective C++, 3d ed
     * by Scott Meyers, ISBN-13: 9780321334879.
     * In Offline's recommendations (https://www.auger.unam.mx/AugerWiki/CppConventions) it's said:
     * "In this respect the use of const_cast<...> is strongly discouraged since it
     * can unravel weird compiler bugs.
     * Use of the mutable keyword is discouraged."
     * The referred may have something to do with
     * (http://gcc.gnu.org/ml/gcc-bugs/2007-12/msg01824.html)
     * "for-loop iterate condition optimized away" posted by Darko Veberic
     * "it seems that with -O2 and when foo is const class, the (it != foo.End())
     * is optimized away as also const (equal true) and the loop does not end, runs
     * over and (usually) produces segfault..."
     *
     * Quoting Meyers:
     * "As a general rule, casting is such a bad idea, I've devoted an entire Item to telling you not
     * to do it (Item 27), but code duplication is no picnic, either. In this case, the const version
     * of operator[] does exactly what the non-const version does, it just has a const-qualified return type.
     * Casting away the const on the return value is safe, in this case, because whoever called the non-const
     * operator[] must have had a non-const object in the first place. Otherwise they couldn't have called
     * a non-const function. So having the non-const operator[] call the const version is a safe way to
     * avoid code duplication, even though it requires a cast."
     *
     * This usage is also favored in
     * "C++ Coding Standards: 101 Rules, Guidelines, and Best Practices" By Herb Sutter, Andrei Alexandrescu.
     * See item exceptions for "94. Avoid casting away const". There they avoid the static_cast thanks to
     * a const reference variable, which may ease over-suspicious coders; anyway stick to Meyer's choice.
     *
     * The static_cast changes this type in order to resolve the desired overloaded method, which returns
     * const, so the const_cast is used to cast away the constness of the returned reference.
     */
    return const_cast<C&>(static_cast<const ComponentGroup&>(*this).Get(id));
  }


  template<class P, class C, class Creator, class ManagerProvider>
  bool
  ComponentGroup<P, C, Creator, ManagerProvider>::Exists(int i)
    const
  {
    // Lazy init...
    if (fComponentsIdsSet.empty()) {
      // ...insert everything in the sequence to the set.
      fComponentsIdsSet.insert(fComponentsIds.begin(), fComponentsIds.end());
    }
    return fComponentsIdsSet.find(i) != fComponentsIdsSet.end();
  }

}


#endif