RhodeCode

 *

 * Copyright (C) 2003-2009

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_BITS_MAP_EXTENDER_H

#define LEMON_BITS_MAP_EXTENDER_H

#include <iterator>

#include <lemon/bits/traits.h>

#include <lemon/concept_check.h>

#include <lemon/concepts/maps.h>

//\file

//\brief Extenders for iterable maps.

namespace lemon {

  // \ingroup graphbits

  //

  // \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) {

      return operator=<MapExtender>(cmap);

    }

    template <typename CMap>

    MapExtender& operator=(const CMap& cmap) {

      Parent::operator=(cmap);

      return *this;

    }

  public:

    class MapIt : public Item {

      typedef Item Parent;

    public:

      typedef typename Map::Value Value;

      MapIt() {}

      MapIt(Invalid i) : Parent(i) { }

      explicit MapIt(Map& _map) : map(_map) {

        map.notifier()->first(*this);

      }

      MapIt(const Map& _map, const Item& item)

        : Parent(item), map(_map) {}

      MapIt& operator++() {

        map.notifier()->next(*this);

        return *this;

      }

      const Map& map;

    };

    class ItemIt : public Item {

      typedef Item Parent;

    public:

      ItemIt() {}

      ItemIt(Invalid i) : Parent(i) { }

      explicit ItemIt(Map& _map) : map(_map) {

        map.notifier()->first(*this);

      }

      ItemIt(const Map& _map, const Item& item)

        : Parent(item), map(_map) {}

      ItemIt& operator++() {

        map.notifier()->next(*this);

        return *this;

      }

    protected:

      const Map& map;

    };

  };

  // \ingroup graphbits

  //

  // \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) {

      return operator=<MapExtender>(cmap);

    }

    template <typename CMap>

    SubMapExtender& operator=(const CMap& cmap) {

      checkConcept<concepts::ReadMap<Key, Value>, CMap>();

      Item it;

      for (graph.first(it); it != INVALID; graph.next(it)) {

        Parent::set(it, cmap[it]);

      }

      return *this;

    }

  public:

    class MapIt : public Item {

      typedef Item Parent;

    public:

      typedef typename Map::Value Value;

      MapIt() {}

      MapIt(Invalid i) : Parent(i) { }

      explicit MapIt(Map& _map) : map(_map) {

        map.graph.first(*this);

      }

      MapIt(const Map& _map, const Item& item)

        : Parent(item), map(_map) {}

      MapIt& operator++() {

      template<typename _ReadWriteMap>

      struct Constraints {

        void constraints() {

          checkConcept<ReadMap<K, T>, _ReadWriteMap >();

          checkConcept<WriteMap<K, T>, _ReadWriteMap >();

        }

      };

    };

    /// Dereferable map concept

    /// Dereferable map concept.

    ///

    template<typename K, typename T, typename R, typename CR>

    class ReferenceMap : public ReadWriteMap<K,T>

    {

    public:

      /// Tag for reference maps.

      typedef True ReferenceMapTag;

      /// The key type of the map.

      typedef K Key;

      /// \brief The value type of the map.

      /// (The type of objects associated with the keys).

      typedef T Value;

      /// The reference type of the map.

      typedef R Reference;

      /// The const reference type of the map.

      typedef CR ConstReference;

    public:

      /// 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;

        const typename _ReferenceMap::Key& own_key;

        typename _ReferenceMap::Value& own_val;

        typename _ReferenceMap::Reference own_ref;

        typename _ReferenceMap::ConstReference own_cref;

        _ReferenceMap& m;

      };

    };

    // @}

  } //namespace concepts

} //namespace lemon

#endif