source: lemon-0.x/src/hugo/sym_map.h @ 842:a4bb28813570

// -*- c++ -*-
#ifndef SYM_MAP_H
#define SYM_MAP_H

///\ingroup graphmaps
///\file
///\brief Graph maps that construates and destruates
///their elements dynamically.

namespace hugo {

/// \addtogroup graphmaps
/// @{

  /** The SymEdgeIt is wrapper class for the EdgeIt. It can be used to
   *  iterate on the symmetric maps when all of the edge - reverse edge pair
   *  has different parity.
   */

  template <typename Graph, typename Edge, typename EdgeIt>
  class SymEdgeIt : public EdgeIt {
  public:

    /** Default constructor.
     */
    SymEdgeIt() 
      : EdgeIt() {}

    /** Graph initialized constructor.
     */
    SymEdgeIt(const Graph& graph) 
      : EdgeIt(graph) {
      while ( (n & 1) && n != -1) {
        EdgeIt::operator++();
      }
    }

    /** Creating invelid SymEdgeIt.
     */
    SymEdgeIt(Invalid invalid) 
      : EdgeIt(invalid) {}

    /** SymEdgeIt from the given Edge.
     */
    SymEdgeIt(const Graph& graph, const Edge& edge)
      : EdgeIt(graph, edge) {
      while ( (n & 1) && n != -1) {
        EdgeIt::operator++();
      }
    }

    /** Increase operator.
     */
    SymEdgeIt& operator++() {
      EdgeIt::operator++();
      while ( (n & 1) && n != -1) {
        EdgeIt::operator++();
      }
      return *this;
    }
  };

  /** The SymMap template class is graph map structure what
   *  wraps an other map structure to use as symmetric map structure.
   *
   *  The template parameter is the MapRegistry that the maps
   *  will belong to and the ValueType.
   */
  template <template <typename, typename> class DynMap, 
            typename MapRegistry, typename Value>
  class SymMap : public DynMap<MapRegistry, Value>{

  private:

    typedef DynMap<MapRegistry, Value> MapImpl;

  public:
                
    /// The graph type of the maps. 
    typedef typename MapRegistry::Graph Graph;

    typedef typename MapImpl::KeyType KeyType;

  public:


    /** Default constructor for the map.
     */
    SymMap() : MapImpl() {}

    /** Graph and Registry initialized map constructor.
     */
    SymMap(const Graph& g, MapRegistry& r) : MapImpl(g, r) {}

    /** Constructor to use default value to initialize the map. 
     */
    SymMap(const Graph& g, MapRegistry& r, const Value& v) 
      : MapImpl(g, r, v) {}

    /** Constructor to copy a map of the same map type.
     */
    SymMap(const SymMap& copy) 
      : MapImpl(static_cast<const MapImpl&>(copy)) {}

    /** Constructor to copy a map of an other map type.
     */
    template <typename CMap> SymMap(const CMap& copy) 
      : MapImpl(copy) {}

    /** Assign operator to copy a map of the same map type.
     */
    SymMap& operator=(const SymMap& copy) {
      MapImpl::operator=(static_cast<const MapImpl&>(copy));
      return *this;
    }

    /** Assign operator to copy a map of an other map type.
     */
    template <typename CMap> SymMap& operator=(const CMap& copy) {
      MapImpl::operator=(copy);
      return *this;
    }
   
    /**
     * The subscript operator. The map can be subscripted by the
     * actual keys of the graph. 
     */
    typename MapImpl::ReferenceType operator[](const KeyType& key) {
      int id = MapImpl::getGraph()->id(key);    
      return MapImpl::operator[](id >> 1);
    } 
                
    /**
     * The const subscript operator. The map can be subscripted by the
     * actual keys of the graph. 
     */
    typename MapImpl::ConstReferenceType operator[](const KeyType& key) const {
      int id = MapImpl::getGraph()->id(key);
      return MapImpl::operator[](id >> 1);
    }
        
    /** Setter function of the map. Equivalent with map[key] = val.
     *  This is a compatibility feature with the not dereferable maps.
     */
    void set(const KeyType& key, const typename MapImpl::ValueType& val) {
      int id = MapImpl::getGraph()->id(key);
      MapImpl::operator[](id >> 1) = val;
    }
                
    /** Add a new key to the map. It called by the map registry.
     */
    void add(const KeyType& key) {
      int id = MapImpl::getGraph()->id(key);
      if (id & 1) return;
      MapImpl::add(key);
    }
                
    /** Erase a key from the map. It called by the map registry.
     */
    void erase(const KeyType& key) {
      int id = MapImpl::getGraph()->id(key);
      if (id & 1) return;
      MapImpl::add(key);
    }
  };

  /// @}
}

#endif