RhodeCode

 */

#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 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:

    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:

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

        }

      };

    };

        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;

        }

      };

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

        }

      };

    };

      };

    };

    /// \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.

        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;

      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.

          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.

      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.