MultiObject.h

Go to the documentation of this file.

#ifndef _utl_MultiObject_h_
#define _utl_MultiObject_h_


#include <utl/IteratorRange.h>
#include <boost/iterator/transform_iterator.hpp>
#include <map>


namespace utl {

  template<typename T>
  class LabeledObject {

  public:
    LabeledObject(const int label, T& obj) : fLabel(label), fObject(&obj) { }

    LabeledObject(const std::pair<int, T*>& pair)
      : fLabel(pair.first), fObject(pair.second) { }


    int GetLabel() const { return fLabel; }

    bool operator==(const LabeledObject& lobj) const
    { return fLabel == lobj.fLabel && *fObject == *lobj.fObject; }

    bool operator!=(const LabeledObject& lobj) const
    { return !operator==(lobj); }

  protected:
    T& GetObject() { return *fObject; }
    const T& GetObject() const { return *fObject; }

  private:
    int fLabel = 0;
    T* fObject = nullptr;

  };


  namespace detail {
    template<typename T, typename LabeledObjectType>
    struct LabeledObjectFunctor {
      LabeledObjectType
      operator()(const typename std::map<int, T*>::value_type& pair) const
      { return LabeledObjectType(pair); }
    };
  }

  template<typename T, typename LabeledObjectType>
  class MultiObject {

  public:
    typedef typename std::map<int, T*> MultiObjectContainer;
    typedef typename utl::detail::LabeledObjectFunctor<T, LabeledObjectType> LabeledObjectFunctor;
    typedef boost::transform_iterator<LabeledObjectFunctor,
                                      typename MultiObjectContainer::iterator,
                                      LabeledObjectType> Iterator;
    typedef boost::transform_iterator<LabeledObjectFunctor,
                                      typename MultiObjectContainer::const_iterator,
                                      LabeledObjectType> ConstIterator;

    Iterator Begin() { return Iterator(fObjects.begin()); }
    ConstIterator Begin() const { return ConstIterator(fObjects.begin()); }
    Iterator End() { return Iterator(fObjects.end()); }
    ConstIterator End() const { return ConstIterator(fObjects.end()); }
    OFFLINE_MAKE_BOTH_FRIEND_RANGES(Iterator, ConstIterator, MultiObject)

    unsigned int GetNLabels() const { return fObjects.size(); }

    bool HasLabel(const int label) const
    { return fObjects.find(label) != fObjects.end(); }

    bool operator==(const MultiObject& mobj) const;

    bool operator!=(const MultiObject& mobj) const
    { return !operator==(mobj); }

    explicit operator bool() const { return !fObjects.empty(); }

    void Clear();

  protected:
    MultiObject() { }

    MultiObject(const MultiObject& mobj) { *this = mobj; }

    MultiObject(MultiObject&& mobj) : fObjects(std::move(mobj.fObjects)) { }

    MultiObject& operator=(const MultiObject& mobj);

    MultiObject&
    operator=(MultiObject&& mobj)
    {
      if (this != &mobj) {
        Clear();
        fObjects = std::move(mobj.fObjects);
      }
      return *this;
    }

    ~MultiObject();

    T& GetObject(const int label = 0);
    const T& GetObject(const int label = 0) const;

    void AddObject(const T& obj, const int label)
    { AddObject(new T(obj), label); }

    void AddObject(T* const obj, const int label);

    void RemoveObject(const int label);

  private:
    typedef typename MultiObjectContainer::iterator InternalIterator;
    typedef typename MultiObjectContainer::const_iterator InternalConstIterator;

    MultiObjectContainer fObjects;

  };

}


#endif