RhodeCode

  // \brief Extender for maps

  template <typename _Map>

  class MapExtender : public _Map {

    typedef _Map Parent;

    typedef typename Parent::GraphType GraphType;

  public:

    typedef MapExtender Map;

    typedef typename Parent::Key Item;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    typedef typename Parent::Reference Reference;

    typedef typename Parent::ConstReference ConstReference;

    class MapIt;

    class ConstMapIt;

    friend class MapIt;

    friend class ConstMapIt;

  public:

    MapExtender(const GraphType& graph)

      : Parent(graph) {}

    MapExtender(const GraphType& graph, const Value& value)

      : Parent(graph, value) {}

  private:

    MapExtender& operator=(const MapExtender& cmap) {

  // \brief Extender for maps which use a subset of the items.

  template <typename _Graph, typename _Map>

  class SubMapExtender : public _Map {

    typedef _Map Parent;

    typedef _Graph GraphType;

  public:

    typedef SubMapExtender Map;

    typedef typename Parent::Key Item;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    typedef typename Parent::Reference Reference;

    typedef typename Parent::ConstReference ConstReference;

    class MapIt;

    class ConstMapIt;

    friend class MapIt;

    friend class ConstMapIt;

  public:

    SubMapExtender(const GraphType& _graph)

      : Parent(_graph), graph(_graph) {}

    SubMapExtender(const GraphType& _graph, const Value& _value)

      : Parent(_graph, _value), graph(_graph) {}

  private:

    SubMapExtender& operator=(const SubMapExtender& cmap) {

      /// Returns a reference to the value associated with the given key.

      Reference operator[](const Key &) {

        return *static_cast<Value *>(0);

      }

      /// Returns a const reference to the value associated with the given key.

      ConstReference operator[](const Key &) const {

        return *static_cast<Value *>(0);

      }

      /// Sets the value associated with the given key.

      void set(const Key &k,const Value &t) { operator[](k)=t; }

      template<typename _ReferenceMap>

      struct Constraints {

          checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();

          ref = m[key];

          m[key] = val;

          m[key] = ref;

          m[key] = cref;

          own_ref = m[own_key];

          m[own_key] = own_val;

          m[own_key] = own_ref;

          m[own_key] = own_cref;

          m[key] = m[own_key];

          m[own_key] = m[key];

        }

        const Key& key;

        Value& val;

        Reference ref;

        ConstReference cref;