RhodeCode

 * 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_GRAPH_ADAPTOR_EXTENDER_H

#define LEMON_BITS_GRAPH_ADAPTOR_EXTENDER_H

#include <lemon/core.h>

#include <lemon/error.h>

namespace lemon {

  template <typename _Digraph>

  class DigraphAdaptorExtender : public _Digraph {

  public:

    typedef _Digraph Parent;

    typedef _Digraph Digraph;

    typedef DigraphAdaptorExtender Adaptor;

    // Base extensions

  class MapExtender : public _Map {

  public:

    typedef _Map Parent;

    typedef MapExtender Map;

    typedef typename Parent::Graph Graph;

    typedef typename Parent::Key Item;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    class MapIt;

    class ConstMapIt;

    friend class MapIt;

    friend class ConstMapIt;

  public:

    MapExtender(const Graph& graph)

      : Parent(graph) {}

  class SubMapExtender : public _Map {

  public:

    typedef _Map Parent;

    typedef SubMapExtender Map;

    typedef _Graph Graph;

    typedef typename Parent::Key Item;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    class MapIt;

    class ConstMapIt;

    friend class MapIt;

    friend class ConstMapIt;

  public:

    SubMapExtender(const Graph& _graph)

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

      /// \brief The running node of the iterator.

      ///

      /// Gives back the running node of the iterator.

      /// It is always the target of the pointed arc.

      Node runningNode(const OutArcIt&) const { return INVALID; }

      /// \brief The opposite node on the given arc.

      ///

      /// Gives back the opposite node on the given arc.

      Node oppositeNode(const Node&, const Arc&) const { return INVALID; }

      ///

      template<class T>

      public:

        ///\e

        NodeMap(const Digraph&) { }

        ///\e

        NodeMap(const Digraph&, T) { }

      private:

        ///Copy constructor

        ///Assignment operator

        template <typename CMap>

        NodeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Node, T>, CMap>();

          return *this;

        }

      };

      ///

      /// Reference map of the arcs to type \c T.

      template<class T>

      public:

        ///\e

        ArcMap(const Digraph&) { }

        ///\e

        ArcMap(const Digraph&, T) { }

      private:

        ///Copy constructor

        ///Assignment operator

        template <typename CMap>

        ArcMap& operator=(const CMap&) {

          checkConcept<ReadMap<Arc, T>, CMap>();

          return *this;

        }

      };

      template <typename _Digraph>

      struct Constraints {

        void constraints() {

          checkConcept<IterableDigraphComponent<>, _Digraph>();

          checkConcept<IDableDigraphComponent<>, _Digraph>();

          checkConcept<MappableDigraphComponent<>, _Digraph>();

        }

      };

    };

  } //namespace concepts

} //namespace lemon

        /// Sets the iterator to the value of the trivial iterator \c e.

        /// This feature necessitates that each time we

        /// iterate the arc-set, the iteration order is the same.

        InArcIt(const Graph&, const Arc&) { }

        /// Next incoming arc

        /// Assign the iterator to the next inarc of the corresponding node.

        ///

        InArcIt& operator++() { return *this; }

      };

      ///

      template<class T>

      {

      public:

        ///\e

        NodeMap(const Graph&) { }

        ///\e

        NodeMap(const Graph&, T) { }

      private:

        ///Copy constructor

        ///Assignment operator

        template <typename CMap>

        NodeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Node, T>, CMap>();

          return *this;

        }

      };

      ///

      template<class T>

      {

      public:

        ///\e

        ArcMap(const Graph&) { }

        ///\e

        ArcMap(const Graph&, T) { }

      private:

        ///Copy constructor

        ///Assignment operator

        template <typename CMap>

        ArcMap& operator=(const CMap&) {

          checkConcept<ReadMap<Arc, T>, CMap>();

          return *this;

        }

      };

      template<class T>

      {

      public:

        ///\e

        EdgeMap(const Graph&) { }

        ///\e

        EdgeMap(const Graph&, T) { }

      private:

        ///Copy constructor

        ///Assignment operator

        template <typename CMap>

        EdgeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Edge, T>, CMap>();

          return *this;

        }

      };

      /// \brief Direct the given edge.

      ///

      /// Direct the given edge. The returned arc source

      /// will be the given node.

      }

      /// \brief Running node of the iterator

      ///

      /// Returns the running node of the iterator

      Node runningNode(IncEdgeIt) const {

        return INVALID;

      }

      template <typename _Graph>

      struct Constraints {

        void constraints() {

          checkConcept<IterableGraphComponent<>, _Graph>();

          checkConcept<IDableGraphComponent<>, _Graph>();

          checkConcept<MappableGraphComponent<>, _Graph>();

        }

      };

    };

  }

}

          ignore_unused_variable_warning(uen);

        }

        const _Graph& graph;

      };

    };

    /// \brief Concept class for standard graph maps.

    ///

    /// This class describes the concept of standard graph maps, i.e.

    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 

    /// graph types, which can be used for associating data to graph items.

    template <typename GR, typename K, typename V>

    public:

      typedef ReadWriteMap<K, V> Parent;

      /// The graph type of the map.

      typedef GR Graph;

      /// The key type of the map.

      typedef K Key;

      /// The value type of the map.

      typedef V Value;

      /// \brief Construct a new map.

      ///

      /// Construct a new map for the graph.

      explicit GraphMap(const Graph&) {}

      /// \brief Construct a new map with default value.

      ///

      /// Construct a new map for the graph and initalize the values.

      GraphMap(const Graph&, const Value&) {}

    private:

      /// \brief Copy constructor.

      /// it just iterates on the current item set and set the  map

      /// with the value returned by the assigned map.

      template <typename CMap>

      GraphMap& operator=(const CMap&) {

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

        return *this;

      }

    public:

      template<typename _Map>

      struct Constraints {

        void constraints() {

          _Map m1(g);

          _Map m2(g,t);

          // Copy constructor

          // _Map m3(m);

          // Assignment operator

          // ReadMap<Key, Value> cmap;

          // m3 = cmap;

          ignore_unused_variable_warning(m1);

          ignore_unused_variable_warning(m2);

    class MappableDigraphComponent : public BAS  {

    public:

      typedef BAS Base;

      typedef typename Base::Node Node;

      typedef typename Base::Arc Arc;

      typedef MappableDigraphComponent Digraph;

      /// \brief Standard graph map for the nodes.

      ///

      /// Standard graph map for the nodes.

      template <typename V>

      class NodeMap : public GraphMap<MappableDigraphComponent, Node, V> {

      public:

        typedef GraphMap<MappableDigraphComponent, Node, V> Parent;

        /// \brief Construct a new map.

        ///

        /// Construct a new map for the digraph.

        explicit NodeMap(const MappableDigraphComponent& digraph)

          : Parent(digraph) {}

        /// \brief Construct a new map with default value.

        /// Assignment operator.

        template <typename CMap>

        NodeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Node, V>, CMap>();

          return *this;

        }

      };

      /// \brief Standard graph map for the arcs.

      ///

      /// Standard graph map for the arcs.

      template <typename V>

      class ArcMap : public GraphMap<MappableDigraphComponent, Arc, V> {

      public:

        typedef GraphMap<MappableDigraphComponent, Arc, V> Parent;

        /// \brief Construct a new map.

        ///

        /// Construct a new map for the digraph.

        explicit ArcMap(const MappableDigraphComponent& digraph)

          : Parent(digraph) {}

        /// \brief Construct a new map with default value.

    template <typename BAS = BaseGraphComponent>

    class MappableGraphComponent : public MappableDigraphComponent<BAS>  {

    public:

      typedef BAS Base;

      typedef typename Base::Edge Edge;

      typedef MappableGraphComponent Graph;

      /// \brief Standard graph map for the edges.

      ///

      /// Standard graph map for the edges.

      template <typename V>

      class EdgeMap : public GraphMap<MappableGraphComponent, Edge, V> {

      public:

        typedef GraphMap<MappableGraphComponent, Edge, V> Parent;

        /// \brief Construct a new map.

        ///

        /// Construct a new map for the graph.

        explicit EdgeMap(const MappableGraphComponent& graph)

          : Parent(graph) {}

        /// \brief Construct a new map with default value.