LEMON/LEMON-main Changeset - r580:2313edd0db0b

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r580:2313edd0db0b

« 579:d11bf7

581:aa1804 »

r580:2313edd0db0b

Tue, 14 Apr 2009 10:34:12

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Standard graph maps are required to be reference maps (#190)

0 5 0

default

5 files changed with 44 insertions and 28 deletions:

lemon/bits/graph_adaptor_extender.h

lemon/bits/map_extender.h

lemon/concepts/digraph.h

lemon/concepts/graph.h

lemon/concepts/graph_components.h

↑ Collapse diff ↑

lemon/bits/graph_adaptor_extender.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_GRAPH_ADAPTOR_EXTENDER_H
 		#define LEMON_BITS_GRAPH_ADAPTOR_EXTENDER_H
 		#include <lemon/core.h>
 		#include <lemon/error.h>
 		#include <lemon/bits/default_map.h>
 		namespace lemon {
 		  template <typename _Digraph>
 		  class DigraphAdaptorExtender : public _Digraph {
 		  public:
 		    typedef _Digraph Parent;
 		    typedef _Digraph Digraph;
 		    typedef DigraphAdaptorExtender Adaptor;
 		    // Base extensions
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Arc &e) const {
 		      if (n == Parent::source(e))
 		        return Parent::target(e);
 		      else if(n==Parent::target(e))
 		        return Parent::source(e);
 		      else
 		        return INVALID;
+		    }
 		    class NodeIt : public Node {
 		      const Adaptor* _adaptor;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Adaptor& adaptor, const Node& node)
 		        : Node(node), _adaptor(&adaptor) {}
 		      NodeIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Adaptor& adaptor, const Arc& e) :
 		        Arc(e), _adaptor(&adaptor) { }
 		      ArcIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Adaptor& adaptor, const Node& node)
 		        : _adaptor(&adaptor) {
 		        _adaptor->firstOut(*this, node);
+		      }
 		      OutArcIt(const Adaptor& adaptor, const Arc& arc)
 		        : Arc(arc), _adaptor(&adaptor) {}
 		      OutArcIt& operator++() {
 		        _adaptor->nextOut(*this);
 		        return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Adaptor& adaptor, const Node& node)
 		        : _adaptor(&adaptor) {
 		        _adaptor->firstIn(*this, node);
+		      }
 		      InArcIt(const Adaptor& adaptor, const Arc& arc) :
 		        Arc(arc), _adaptor(&adaptor) {}
 		      InArcIt& operator++() {
 		        _adaptor->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    Node baseNode(const OutArcIt &e) const {
 		      return Parent::source(e);
+		    }
 		    Node runningNode(const OutArcIt &e) const {
 		      return Parent::target(e);
+		    }
 		    Node baseNode(const InArcIt &e) const {
 		      return Parent::target(e);
+		    }
 		    Node runningNode(const InArcIt &e) const {
 		      return Parent::source(e);
+		    }
 		  };
 		  template <typename _Graph>
 		  class GraphAdaptorExtender : public _Graph {
 		  public:
 		    typedef _Graph Parent;
 		    typedef _Graph Graph;
 		    typedef GraphAdaptorExtender Adaptor;
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    typedef typename Parent::Edge Edge;
 		    // Graph extension
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    int maxId(Edge) const {
 		      return Parent::maxEdgeId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Edge fromId(int id, Edge) const {
 		      return Parent::edgeFromId(id);
+		    }
 		    Node oppositeNode(const Node &n, const Edge &e) const {
 		      if( n == Parent::u(e))
 		        return Parent::v(e);
 		      else if( n == Parent::v(e))
 		        return Parent::u(e);
 		      else
 		        return INVALID;
+		    }
 		    Arc oppositeArc(const Arc &a) const {
 		      return Parent::direct(a, !Parent::direction(a));
+		    }
 		    using Parent::direct;
 		    Arc direct(const Edge &e, const Node &s) const {
 		      return Parent::direct(e, Parent::u(e) == s);
+		    }
 		    class NodeIt : public Node {
 		      const Adaptor* _adaptor;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Adaptor& adaptor, const Node& node)
 		        : Node(node), _adaptor(&adaptor) {}
 		      NodeIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Adaptor& adaptor, const Arc& e) :
 		        Arc(e), _adaptor(&adaptor) { }
 		      ArcIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Adaptor& adaptor, const Node& node)
 		        : _adaptor(&adaptor) {
 		        _adaptor->firstOut(*this, node);
+		      }
 		      OutArcIt(const Adaptor& adaptor, const Arc& arc)
 		        : Arc(arc), _adaptor(&adaptor) {}
 		      OutArcIt& operator++() {
 		        _adaptor->nextOut(*this);
 		        return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Adaptor* _adaptor;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Adaptor& adaptor, const Node& node)
 		        : _adaptor(&adaptor) {
 		        _adaptor->firstIn(*this, node);
+		      }
 		      InArcIt(const Adaptor& adaptor, const Arc& arc) :
 		        Arc(arc), _adaptor(&adaptor) {}
 		      InArcIt& operator++() {
 		        _adaptor->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    class EdgeIt : public Parent::Edge {
 		      const Adaptor* _adaptor;
 		    public:
 		      EdgeIt() { }
 		      EdgeIt(Invalid i) : Edge(i) { }
 		      explicit EdgeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
 		        _adaptor->first(static_cast<Edge&>(*this));
+		      }
 		      EdgeIt(const Adaptor& adaptor, const Edge& e) :
 		        Edge(e), _adaptor(&adaptor) { }
 		      EdgeIt& operator++() {
 		        _adaptor->next(*this);
 		        return *this;
+		      }
 		    };
 		    class IncEdgeIt : public Edge {
 		      friend class GraphAdaptorExtender;
 		      const Adaptor* _adaptor;
 		      bool direction;
 		    public:
 		      IncEdgeIt() { }
 		      IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
 		      IncEdgeIt(const Adaptor& adaptor, const Node &n) : _adaptor(&adaptor) {
 		        _adaptor->firstInc(static_cast<Edge&>(*this), direction, n);
+		      }
 		      IncEdgeIt(const Adaptor& adaptor, const Edge &e, const Node &n)
 		        : _adaptor(&adaptor), Edge(e) {
 		        direction = (_adaptor->u(e) == n);
+		      }
 		      IncEdgeIt& operator++() {
 		        _adaptor->nextInc(*this, direction);
 		        return *this;
+		      }
 		    };
 		    Node baseNode(const OutArcIt &a) const {
 		      return Parent::source(a);
+		    }
 		    Node runningNode(const OutArcIt &a) const {
 		      return Parent::target(a);
+		    }
 		    Node baseNode(const InArcIt &a) const {
 		      return Parent::target(a);
+		    }
 		    Node runningNode(const InArcIt &a) const {
 		      return Parent::source(a);
+		    }
 		    Node baseNode(const IncEdgeIt &e) const {
 		      return e.direction ? Parent::u(e) : Parent::v(e);
+		    }
 		    Node runningNode(const IncEdgeIt &e) const {
 		      return e.direction ? Parent::v(e) : Parent::u(e);
+		    }
 		  };
+		}
 		#endif

lemon/bits/map_extender.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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 {
 		  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;
 		    typedef typename Parent::Reference Reference;
 		    typedef typename Parent::ConstReference ConstReference;
 		    class MapIt;
 		    class ConstMapIt;
 		    friend class MapIt;
 		    friend class ConstMapIt;
 		  public:
 		    MapExtender(const Graph& graph)
 		      : Parent(graph) {}
 		    MapExtender(const Graph& 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 {
 		    public:
 		      typedef Item Parent;
 		      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;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 		        return map[*this];
+		      }
 		      typename MapTraits<Map>::ReturnValue operator*() {
 		        return map[*this];
+		      }
 		      void set(const Value& value) {
 		        map.set(*this, value);
+		      }
 		    protected:
 		      Map& map;
 		    };
 		    class ConstMapIt : public Item {
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      ConstMapIt() {}
 		      ConstMapIt(Invalid i) : Parent(i) { }
 		      explicit ConstMapIt(Map& _map) : map(_map) {
 		        map.notifier()->first(*this);
+		      }
 		      ConstMapIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      ConstMapIt& operator++() {
 		        map.notifier()->next(*this);
 		        return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 		        return map[*this];
+		      }
 		    protected:
 		      const Map& map;
 		    };
 		    class ItemIt : public Item {
 		    public:
 		      typedef Item Parent;
 		      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 {
 		  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;
 		    typedef typename Parent::Reference Reference;
 		    typedef typename Parent::ConstReference ConstReference;
 		    class MapIt;
 		    class ConstMapIt;
 		    friend class MapIt;
 		    friend class ConstMapIt;
 		  public:
 		    SubMapExtender(const Graph& _graph)
 		      : Parent(_graph), graph(_graph) {}
 		    SubMapExtender(const Graph& _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 {
 		    public:
 		      typedef Item Parent;
 		      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++() {
 		        map.graph.next(*this);
 		        return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 		        return map[*this];
+		      }
 		      typename MapTraits<Map>::ReturnValue operator*() {
 		        return map[*this];
+		      }
 		      void set(const Value& value) {
 		        map.set(*this, value);
+		      }
 		    protected:
 		      Map& map;
 		    };
 		    class ConstMapIt : public Item {
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      ConstMapIt() {}
 		      ConstMapIt(Invalid i) : Parent(i) { }
 		      explicit ConstMapIt(Map& _map) : map(_map) {
 		        map.graph.first(*this);
+		      }
 		      ConstMapIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      ConstMapIt& operator++() {
 		        map.graph.next(*this);
 		        return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 		        return map[*this];
+		      }
 		    protected:
 		      const Map& map;
 		    };
 		    class ItemIt : public Item {
 		    public:
 		      typedef Item Parent;
 		      ItemIt() {}
 		      ItemIt(Invalid i) : Parent(i) { }
 		      explicit ItemIt(Map& _map) : map(_map) {
 		        map.graph.first(*this);
+		      }
 		      ItemIt(const Map& _map, const Item& item)
 		        : Parent(item), map(_map) {}
 		      ItemIt& operator++() {
 		        map.graph.next(*this);
 		        return *this;
+		      }
 		    protected:
 		      const Map& map;
 		    };
 		  private:
 		    const Graph& graph;
 		  };
+		}
 		#endif

lemon/concepts/digraph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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_CONCEPTS_DIGRAPH_H
 		#define LEMON_CONCEPTS_DIGRAPH_H
 		///\ingroup graph_concepts
 		///\file
 		///\brief The concept of directed graphs.
 		#include <lemon/core.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/graph_components.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \ingroup graph_concepts
 		    ///
 		    /// \brief Class describing the concept of directed graphs.
 		    ///
 		    /// This class describes the \ref concept "concept" of the
 		    /// immutable directed digraphs.
 		    ///
 		    /// Note that actual digraph implementation like @ref ListDigraph or
 		    /// @ref SmartDigraph may have several additional functionality.
 		    ///
 		    /// \sa concept
 		    class Digraph {
 		    private:
 		      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
 		      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
 		      ///
 		      Digraph(const Digraph &) {};
 		      ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
 		      ///\e not allowed. Use DigraphCopy() instead.
 		      ///Assignment of \ref Digraph "Digraph"s to another ones are
 		      ///\e not allowed.  Use DigraphCopy() instead.
 		      void operator=(const Digraph &) {}
 		    public:
 		      ///\e
 		      /// Defalult constructor.
 		      /// Defalult constructor.
 		      ///
 		      Digraph() { }
 		      /// Class for identifying a node of the digraph
 		      /// This class identifies a node of the digraph. It also serves
 		      /// as a base class of the node iterators,
 		      /// thus they will convert to this type.
 		      class Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Node() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Node(const Node&) { }
 		        /// Invalid constructor \& conversion.
 		        /// This constructor initializes the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        Node(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Node) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Node n)
 		        ///
 		        bool operator!=(Node) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of digraph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Node) const { return false; }
 		      };
 		      /// This iterator goes through each node.
 		      /// This iterator goes through each node.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of nodes in digraph \c g of type \c Digraph like this:
 		      ///\code
 		      /// int count=0;
 		      /// for (Digraph::NodeIt n(g); n!=INVALID; ++n) ++count;
 		      ///\endcode
 		      class NodeIt : public Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        NodeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        NodeIt(const NodeIt& n) : Node(n) { }
 		        /// Invalid constructor \& conversion.
 		        /// Initialize the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        NodeIt(Invalid) { }
 		        /// Sets the iterator to the first node.
 		        /// Sets the iterator to the first node of \c g.
 		        ///
 		        NodeIt(const Digraph&) { }
 		        /// Node -> NodeIt conversion.
 		        /// Sets the iterator to the node of \c the digraph pointed by
 		        /// the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        NodeIt(const Digraph&, const Node&) { }
 		        /// Next node.
 		        /// Assign the iterator to the next node.
 		        ///
 		        NodeIt& operator++() { return *this; }
 		      };
 		      /// Class for identifying an arc of the digraph
 		      /// This class identifies an arc of the digraph. It also serves
 		      /// as a base class of the arc iterators,
 		      /// thus they will convert to this type.
 		      class Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Arc() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Arc(const Arc&) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        Arc(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Arc) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Arc n)
 		        ///
 		        bool operator!=(Arc) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of digraph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Arc) const { return false; }
 		      };
 		      /// This iterator goes trough the outgoing arcs of a node.
 		      /// This iterator goes trough the \e outgoing arcs of a certain node
 		      /// of a digraph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in digraph \c g of type \c Digraph as follows.
 		      ///\code
 		      /// int count=0;
 		      /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class OutArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        OutArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        OutArcIt(const OutArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        OutArcIt(Invalid) { }
 		        /// This constructor sets the iterator to the first outgoing arc.
 		        /// This constructor sets the iterator to the first outgoing arc of
 		        /// the node.
 		        OutArcIt(const Digraph&, const Node&) { }
 		        /// Arc -> OutArcIt conversion
 		        /// Sets the iterator to the value of the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        OutArcIt(const Digraph&, const Arc&) { }
 		        ///Next outgoing arc
 		        /// Assign the iterator to the next
 		        /// outgoing arc of the corresponding node.
 		        OutArcIt& operator++() { return *this; }
 		      };
 		      /// This iterator goes trough the incoming arcs of a node.
 		      /// This iterator goes trough the \e incoming arcs of a certain node
 		      /// of a digraph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in digraph \c g of type \c Digraph as follows.
 		      ///\code
 		      /// int count=0;
 		      /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class InArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        InArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        InArcIt(const InArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        InArcIt(Invalid) { }
 		        /// This constructor sets the iterator to first incoming arc.
 		        /// This constructor set the iterator to the first incoming arc of
 		        /// the node.
 		        InArcIt(const Digraph&, const Node&) { }
 		        /// Arc -> InArcIt conversion
 		        /// 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 Digraph&, const Arc&) { }
 		        /// Next incoming arc
 		        /// Assign the iterator to the next inarc of the corresponding node.
 		        ///
 		        InArcIt& operator++() { return *this; }
 		      };
 		      /// This iterator goes through each arc.
 		      /// This iterator goes through each arc of a digraph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of arcs in a digraph \c g of type \c Digraph as follows:
 		      ///\code
 		      /// int count=0;
 		      /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class ArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        ArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        ArcIt(const ArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        ArcIt(Invalid) { }
 		        /// This constructor sets the iterator to the first arc.
 		        /// This constructor sets the iterator to the first arc of \c g.
 		        ///@param g the digraph
 		        ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
 		        /// Arc -> ArcIt conversion
 		        /// 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.
 		        ArcIt(const Digraph&, const Arc&) { }
 		        ///Next arc
 		        /// Assign the iterator to the next arc.
 		        ArcIt& operator++() { return *this; }
 		      };
 		      ///Gives back the target node of an arc.
 		      ///Gives back the target node of an arc.
 		      ///
 		      Node target(Arc) const { return INVALID; }
 		      ///Gives back the source node of an arc.
 		      ///Gives back the source node of an arc.
 		      ///
 		      Node source(Arc) const { return INVALID; }
 		      /// \brief Returns the ID of the node.
 		      int id(Node) const { return -1; }
 		      /// \brief Returns the ID of the arc.
 		      int id(Arc) const { return -1; }
 		      /// \brief Returns the node with the given ID.
 		      ///
 		      /// \pre The argument should be a valid node ID in the graph.
 		      Node nodeFromId(int) const { return INVALID; }
 		      /// \brief Returns the arc with the given ID.
 		      ///
 		      /// \pre The argument should be a valid arc ID in the graph.
 		      Arc arcFromId(int) const { return INVALID; }
 		      /// \brief Returns an upper bound on the node IDs.
 		      int maxNodeId() const { return -1; }
 		      /// \brief Returns an upper bound on the arc IDs.
 		      int maxArcId() const { return -1; }
 		      void first(Node&) const {}
 		      void next(Node&) const {}
 		      void first(Arc&) const {}
 		      void next(Arc&) const {}
 		      void firstIn(Arc&, const Node&) const {}
 		      void nextIn(Arc&) const {}
 		      void firstOut(Arc&, const Node&) const {}
 		      void nextOut(Arc&) const {}
 		      // The second parameter is dummy.
 		      Node fromId(int, Node) const { return INVALID; }
 		      // The second parameter is dummy.
 		      Arc fromId(int, Arc) const { return INVALID; }
 		      // Dummy parameter.
 		      int maxId(Node) const { return -1; }
 		      // Dummy parameter.
 		      int maxId(Arc) const { return -1; }
 		      /// \brief The base node of the iterator.
 		      ///
 		      /// Gives back the base node of the iterator.
 		      /// It is always the target of the pointed arc.
 		      Node baseNode(const InArcIt&) const { return INVALID; }
 		      /// \brief The running node of the iterator.
 		      ///
 		      /// Gives back the running node of the iterator.
 		      /// It is always the source of the pointed arc.
 		      Node runningNode(const InArcIt&) const { return INVALID; }
 		      /// \brief The base node of the iterator.
 		      ///
 		      /// Gives back the base node of the iterator.
 		      /// It is always the source of the pointed arc.
 		      Node baseNode(const OutArcIt&) const { return INVALID; }
 		      /// \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; }
-		      /// \brief Read write map of the nodes to type \c T.
+		      /// \brief Reference map of the nodes to type \c T.
 		      ///
 		      /// ReadWrite map of the nodes to type \c T.
 		      /// \sa Reference
 		      /// Reference map of the nodes to type \c T.
 		      template<class T>
-		      class NodeMap : public ReadWriteMap< Node, T > {
+		      class NodeMap : public ReferenceMap<Node, T, T&, const T&> {
 		      public:
 		        ///\e
 		        NodeMap(const Digraph&) { }
 		        ///\e
 		        NodeMap(const Digraph&, T) { }
 		      private:
 		        ///Copy constructor
-		        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
 		        NodeMap(const NodeMap& nm) :
 		          ReferenceMap<Node, T, T&, const T&>(nm) { }
 		        ///Assignment operator
 		        template <typename CMap>
 		        NodeMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Node, T>, CMap>();
 		          return *this;
+		        }
 		      };
-		      /// \brief Read write map of the arcs to type \c T.
+		      /// \brief Reference map of the arcs to type \c T.
 		      ///
 		      /// Reference map of the arcs to type \c T.
 		      /// \sa Reference
 		      template<class T>
-		      class ArcMap : public ReadWriteMap<Arc,T> {
+		      class ArcMap : public ReferenceMap<Arc, T, T&, const T&> {
 		      public:
 		        ///\e
 		        ArcMap(const Digraph&) { }
 		        ///\e
 		        ArcMap(const Digraph&, T) { }
 		      private:
 		        ///Copy constructor
-		        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }
 		        ArcMap(const ArcMap& em) :
 		          ReferenceMap<Arc, T, T&, const T&>(em) { }
 		        ///Assignment operator
 		        template <typename CMap>
 		        ArcMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Arc, T>, CMap>();
 		          return *this;
+		        }
 		      };
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<BaseDigraphComponent, _Digraph>();
 		          checkConcept<IterableDigraphComponent<>, _Digraph>();
 		          checkConcept<IDableDigraphComponent<>, _Digraph>();
 		          checkConcept<MappableDigraphComponent<>, _Digraph>();
+		        }
 		      };
 		    };
 		  } //namespace concepts
 		} //namespace lemon
 		#endif

lemon/concepts/graph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * 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.
+		 *
 		 */
 		///\ingroup graph_concepts
 		///\file
 		///\brief The concept of Undirected Graphs.
 		#ifndef LEMON_CONCEPTS_GRAPH_H
 		#define LEMON_CONCEPTS_GRAPH_H
 		#include <lemon/concepts/graph_components.h>
 		#include <lemon/core.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \ingroup graph_concepts
 		    ///
 		    /// \brief Class describing the concept of Undirected Graphs.
 		    ///
 		    /// This class describes the common interface of all Undirected
 		    /// Graphs.
 		    ///
 		    /// As all concept describing classes it provides only interface
 		    /// without any sensible implementation. So any algorithm for
 		    /// undirected graph should compile with this class, but it will not
 		    /// run properly, of course.
 		    ///
 		    /// The LEMON undirected graphs also fulfill the concept of
 		    /// directed graphs (\ref lemon::concepts::Digraph "Digraph
 		    /// Concept"). Each edges can be seen as two opposite
 		    /// directed arc and consequently the undirected graph can be
 		    /// seen as the direceted graph of these directed arcs. The
 		    /// Graph has the Edge inner class for the edges and
 		    /// the Arc type for the directed arcs. The Arc type is
 		    /// convertible to Edge or inherited from it so from a directed
 		    /// arc we can get the represented edge.
 		    ///
 		    /// In the sense of the LEMON each edge has a default
 		    /// direction (it should be in every computer implementation,
 		    /// because the order of edge's nodes defines an
 		    /// orientation). With the default orientation we can define that
 		    /// the directed arc is forward or backward directed. With the \c
 		    /// direction() and \c direct() function we can get the direction
 		    /// of the directed arc and we can direct an edge.
 		    ///
 		    /// The EdgeIt is an iterator for the edges. We can use
 		    /// the EdgeMap to map values for the edges. The InArcIt and
 		    /// OutArcIt iterates on the same edges but with opposite
 		    /// direction. The IncEdgeIt iterates also on the same edges
 		    /// as the OutArcIt and InArcIt but it is not convertible to Arc just
 		    /// to Edge.
 		    class Graph {
 		    public:
 		      /// \brief The undirected graph should be tagged by the
 		      /// UndirectedTag.
 		      ///
 		      /// The undirected graph should be tagged by the UndirectedTag. This
 		      /// tag helps the enable_if technics to make compile time
 		      /// specializations for undirected graphs.
 		      typedef True UndirectedTag;
 		      /// \brief The base type of node iterators,
 		      /// or in other words, the trivial node iterator.
 		      ///
 		      /// This is the base type of each node iterator,
 		      /// thus each kind of node iterator converts to this.
 		      /// More precisely each kind of node iterator should be inherited
 		      /// from the trivial node iterator.
 		      class Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Node() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Node(const Node&) { }
 		        /// Invalid constructor \& conversion.
 		        /// This constructor initializes the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        Node(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Node) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Node n)
 		        ///
 		        bool operator!=(Node) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of graph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Node) const { return false; }
 		      };
 		      /// This iterator goes through each node.
 		      /// This iterator goes through each node.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of nodes in graph \c g of type \c Graph like this:
 		      ///\code
 		      /// int count=0;
 		      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
 		      ///\endcode
 		      class NodeIt : public Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        NodeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        NodeIt(const NodeIt& n) : Node(n) { }
 		        /// Invalid constructor \& conversion.
 		        /// Initialize the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        NodeIt(Invalid) { }
 		        /// Sets the iterator to the first node.
 		        /// Sets the iterator to the first node of \c g.
 		        ///
 		        NodeIt(const Graph&) { }
 		        /// Node -> NodeIt conversion.
 		        /// Sets the iterator to the node of \c the graph pointed by
 		        /// the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        NodeIt(const Graph&, const Node&) { }
 		        /// Next node.
 		        /// Assign the iterator to the next node.
 		        ///
 		        NodeIt& operator++() { return *this; }
 		      };
 		      /// The base type of the edge iterators.
 		      /// The base type of the edge iterators.
 		      ///
 		      class Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Edge() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Edge(const Edge&) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        Edge(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Edge) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Edge n)
 		        ///
 		        bool operator!=(Edge) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of graph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Edge) const { return false; }
 		      };
 		      /// This iterator goes through each edge.
 		      /// This iterator goes through each edge of a graph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of edges in a graph \c g of type \c Graph as follows:
 		      ///\code
 		      /// int count=0;
 		      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class EdgeIt : public Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        EdgeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        EdgeIt(const EdgeIt& e) : Edge(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        EdgeIt(Invalid) { }
 		        /// This constructor sets the iterator to the first edge.
 		        /// This constructor sets the iterator to the first edge.
 		        EdgeIt(const Graph&) { }
 		        /// Edge -> EdgeIt conversion
 		        /// Sets the iterator to the value of the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the edge-set, the iteration order is the
 		        /// same.
 		        EdgeIt(const Graph&, const Edge&) { }
 		        /// Next edge
 		        /// Assign the iterator to the next edge.
 		        EdgeIt& operator++() { return *this; }
 		      };
 		      /// \brief This iterator goes trough the incident undirected
 		      /// arcs of a node.
 		      ///
 		      /// This iterator goes trough the incident edges
 		      /// of a certain node of a graph. You should assume that the
 		      /// loop arcs will be iterated twice.
 		      ///
 		      /// Its usage is quite simple, for example you can compute the
 		      /// degree (i.e. count the number of incident arcs of a node \c n
 		      /// in graph \c g of type \c Graph as follows.
 		      ///
 		      ///\code
 		      /// int count=0;
 		      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class IncEdgeIt : public Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        IncEdgeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        IncEdgeIt(Invalid) { }
 		        /// This constructor sets the iterator to first incident arc.
 		        /// This constructor set the iterator to the first incident arc of
 		        /// the node.
 		        IncEdgeIt(const Graph&, const Node&) { }
 		        /// Edge -> IncEdgeIt conversion
 		        /// 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.
 		        IncEdgeIt(const Graph&, const Edge&) { }
 		        /// Next incident arc
 		        /// Assign the iterator to the next incident arc
 		        /// of the corresponding node.
 		        IncEdgeIt& operator++() { return *this; }
 		      };
 		      /// The directed arc type.
 		      /// The directed arc type. It can be converted to the
 		      /// edge or it should be inherited from the undirected
 		      /// arc.
 		      class Arc : public Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Arc() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Arc(const Arc& e) : Edge(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        Arc(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Arc) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Arc n)
 		        ///
 		        bool operator!=(Arc) const { return true; }
 		        /// Artificial ordering operator.
 		        /// To allow the use of graph descriptors as key type in std::map or
 		        /// similar associative container we require this.
 		        ///
 		        /// \note This operator only have to define some strict ordering of
 		        /// the items; this order has nothing to do with the iteration
 		        /// ordering of the items.
 		        bool operator<(Arc) const { return false; }
 		      };
 		      /// This iterator goes through each directed arc.
 		      /// This iterator goes through each arc of a graph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of arcs in a graph \c g of type \c Graph as follows:
 		      ///\code
 		      /// int count=0;
 		      /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class ArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        ArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        ArcIt(const ArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        ArcIt(Invalid) { }
 		        /// This constructor sets the iterator to the first arc.
 		        /// This constructor sets the iterator to the first arc of \c g.
 		        ///@param g the graph
 		        ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
 		        /// Arc -> ArcIt conversion
 		        /// 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.
 		        ArcIt(const Graph&, const Arc&) { }
 		        ///Next arc
 		        /// Assign the iterator to the next arc.
 		        ArcIt& operator++() { return *this; }
 		      };
 		      /// This iterator goes trough the outgoing directed arcs of a node.
 		      /// This iterator goes trough the \e outgoing arcs of a certain node
 		      /// of a graph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in graph \c g of type \c Graph as follows.
 		      ///\code
 		      /// int count=0;
 		      /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class OutArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        OutArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        OutArcIt(const OutArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        OutArcIt(Invalid) { }
 		        /// This constructor sets the iterator to the first outgoing arc.
 		        /// This constructor sets the iterator to the first outgoing arc of
 		        /// the node.
 		        ///@param n the node
 		        ///@param g the graph
 		        OutArcIt(const Graph& n, const Node& g) {
 		          ignore_unused_variable_warning(n);
 		          ignore_unused_variable_warning(g);
+		        }
 		        /// Arc -> OutArcIt conversion
 		        /// Sets the iterator to the value of the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        OutArcIt(const Graph&, const Arc&) { }
 		        ///Next outgoing arc
 		        /// Assign the iterator to the next
 		        /// outgoing arc of the corresponding node.
 		        OutArcIt& operator++() { return *this; }
 		      };
 		      /// This iterator goes trough the incoming directed arcs of a node.
 		      /// This iterator goes trough the \e incoming arcs of a certain node
 		      /// of a graph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in graph \c g of type \c Graph as follows.
 		      ///\code
 		      /// int count=0;
 		      /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class InArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        InArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        InArcIt(const InArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        InArcIt(Invalid) { }
 		        /// This constructor sets the iterator to first incoming arc.
 		        /// This constructor set the iterator to the first incoming arc of
 		        /// the node.
 		        ///@param n the node
 		        ///@param g the graph
 		        InArcIt(const Graph& g, const Node& n) {
 		          ignore_unused_variable_warning(n);
 		          ignore_unused_variable_warning(g);
+		        }
 		        /// Arc -> InArcIt conversion
 		        /// 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; }
 		      };
-		      /// \brief Read write map of the nodes to type \c T.
+		      /// \brief Reference map of the nodes to type \c T.
 		      ///
 		      /// ReadWrite map of the nodes to type \c T.
 		      /// \sa Reference
 		      /// Reference map of the nodes to type \c T.
 		      template<class T>
-		      class NodeMap : public ReadWriteMap< Node, T >
+		      class NodeMap : public ReferenceMap<Node, T, T&, const T&>
+		      {
 		      public:
 		        ///\e
 		        NodeMap(const Graph&) { }
 		        ///\e
 		        NodeMap(const Graph&, T) { }
 		      private:
 		        ///Copy constructor
-		        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
 		        NodeMap(const NodeMap& nm) :
 		          ReferenceMap<Node, T, T&, const T&>(nm) { }
 		        ///Assignment operator
 		        template <typename CMap>
 		        NodeMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Node, T>, CMap>();
 		          return *this;
+		        }
 		      };
-		      /// \brief Read write map of the directed arcs to type \c T.
+		      /// \brief Reference map of the arcs to type \c T.
 		      ///
 		      /// Reference map of the directed arcs to type \c T.
 		      /// \sa Reference
 		      /// Reference map of the arcs to type \c T.
 		      template<class T>
-		      class ArcMap : public ReadWriteMap<Arc,T>
+		      class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
+		      {
 		      public:
 		        ///\e
 		        ArcMap(const Graph&) { }
 		        ///\e
 		        ArcMap(const Graph&, T) { }
 		      private:
 		        ///Copy constructor
-		        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }
 		        ArcMap(const ArcMap& em) :
 		          ReferenceMap<Arc, T, T&, const T&>(em) { }
 		        ///Assignment operator
 		        template <typename CMap>
 		        ArcMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Arc, T>, CMap>();
 		          return *this;
+		        }
 		      };
-		      /// Read write map of the edges to type \c T.
+		      /// Reference map of the edges to type \c T.
 		      /// Reference map of the arcs to type \c T.
 		      /// \sa Reference
 		      /// Reference map of the edges to type \c T.
 		      template<class T>
-		      class EdgeMap : public ReadWriteMap<Edge,T>
+		      class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
+		      {
 		      public:
 		        ///\e
 		        EdgeMap(const Graph&) { }
 		        ///\e
 		        EdgeMap(const Graph&, T) { }
 		      private:
 		        ///Copy constructor
-		        EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) {}
 		        EdgeMap(const EdgeMap& em) :
 		          ReferenceMap<Edge, T, T&, const T&>(em) {}
 		        ///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.
 		      Arc direct(const Edge&, const Node&) const {
 		        return INVALID;
+		      }
 		      /// \brief Direct the given edge.
 		      ///
 		      /// Direct the given edge. The returned arc
 		      /// represents the given edge and the direction comes
 		      /// from the bool parameter. The source of the edge and
 		      /// the directed arc is the same when the given bool is true.
 		      Arc direct(const Edge&, bool) const {
 		        return INVALID;
+		      }
 		      /// \brief Returns true if the arc has default orientation.
 		      ///
 		      /// Returns whether the given directed arc is same orientation as
 		      /// the corresponding edge's default orientation.
 		      bool direction(Arc) const { return true; }
 		      /// \brief Returns the opposite directed arc.
 		      ///
 		      /// Returns the opposite directed arc.
 		      Arc oppositeArc(Arc) const { return INVALID; }
 		      /// \brief Opposite node on an arc
 		      ///
 		      /// \return The opposite of the given node on the given edge.
 		      Node oppositeNode(Node, Edge) const { return INVALID; }
 		      /// \brief First node of the edge.
 		      ///
 		      /// \return The first node of the given edge.
 		      ///
 		      /// Naturally edges don't have direction and thus
 		      /// don't have source and target node. However we use \c u() and \c v()
 		      /// methods to query the two nodes of the arc. The direction of the
 		      /// arc which arises this way is called the inherent direction of the
 		      /// edge, and is used to define the "default" direction
 		      /// of the directed versions of the arcs.
 		      /// \sa v()
 		      /// \sa direction()
 		      Node u(Edge) const { return INVALID; }
 		      /// \brief Second node of the edge.
 		      ///
 		      /// \return The second node of the given edge.
 		      ///
 		      /// Naturally edges don't have direction and thus
 		      /// don't have source and target node. However we use \c u() and \c v()
 		      /// methods to query the two nodes of the arc. The direction of the
 		      /// arc which arises this way is called the inherent direction of the
 		      /// edge, and is used to define the "default" direction
 		      /// of the directed versions of the arcs.
 		      /// \sa u()
 		      /// \sa direction()
 		      Node v(Edge) const { return INVALID; }
 		      /// \brief Source node of the directed arc.
 		      Node source(Arc) const { return INVALID; }
 		      /// \brief Target node of the directed arc.
 		      Node target(Arc) const { return INVALID; }
 		      /// \brief Returns the id of the node.
 		      int id(Node) const { return -1; }
 		      /// \brief Returns the id of the edge.
 		      int id(Edge) const { return -1; }
 		      /// \brief Returns the id of the arc.
 		      int id(Arc) const { return -1; }
 		      /// \brief Returns the node with the given id.
 		      ///
 		      /// \pre The argument should be a valid node id in the graph.
 		      Node nodeFromId(int) const { return INVALID; }
 		      /// \brief Returns the edge with the given id.
 		      ///
 		      /// \pre The argument should be a valid edge id in the graph.
 		      Edge edgeFromId(int) const { return INVALID; }
 		      /// \brief Returns the arc with the given id.
 		      ///
 		      /// \pre The argument should be a valid arc id in the graph.
 		      Arc arcFromId(int) const { return INVALID; }
 		      /// \brief Returns an upper bound on the node IDs.
 		      int maxNodeId() const { return -1; }
 		      /// \brief Returns an upper bound on the edge IDs.
 		      int maxEdgeId() const { return -1; }
 		      /// \brief Returns an upper bound on the arc IDs.
 		      int maxArcId() const { return -1; }
 		      void first(Node&) const {}
 		      void next(Node&) const {}
 		      void first(Edge&) const {}
 		      void next(Edge&) const {}
 		      void first(Arc&) const {}
 		      void next(Arc&) const {}
 		      void firstOut(Arc&, Node) const {}
 		      void nextOut(Arc&) const {}
 		      void firstIn(Arc&, Node) const {}
 		      void nextIn(Arc&) const {}
 		      void firstInc(Edge &, bool &, const Node &) const {}
 		      void nextInc(Edge &, bool &) const {}
 		      // The second parameter is dummy.
 		      Node fromId(int, Node) const { return INVALID; }
 		      // The second parameter is dummy.
 		      Edge fromId(int, Edge) const { return INVALID; }
 		      // The second parameter is dummy.
 		      Arc fromId(int, Arc) const { return INVALID; }
 		      // Dummy parameter.
 		      int maxId(Node) const { return -1; }
 		      // Dummy parameter.
 		      int maxId(Edge) const { return -1; }
 		      // Dummy parameter.
 		      int maxId(Arc) const { return -1; }
 		      /// \brief Base node of the iterator
 		      ///
 		      /// Returns the base node (the source in this case) of the iterator
 		      Node baseNode(OutArcIt e) const {
 		        return source(e);
+		      }
 		      /// \brief Running node of the iterator
 		      ///
 		      /// Returns the running node (the target in this case) of the
 		      /// iterator
 		      Node runningNode(OutArcIt e) const {
 		        return target(e);
+		      }
 		      /// \brief Base node of the iterator
 		      ///
 		      /// Returns the base node (the target in this case) of the iterator
 		      Node baseNode(InArcIt e) const {
 		        return target(e);
+		      }
 		      /// \brief Running node of the iterator
 		      ///
 		      /// Returns the running node (the source in this case) of the
 		      /// iterator
 		      Node runningNode(InArcIt e) const {
 		        return source(e);
+		      }
 		      /// \brief Base node of the iterator
 		      ///
 		      /// Returns the base node of the iterator
 		      Node baseNode(IncEdgeIt) const {
 		        return INVALID;
+		      }
 		      /// \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<BaseGraphComponent, _Graph>();
 		          checkConcept<IterableGraphComponent<>, _Graph>();
 		          checkConcept<IDableGraphComponent<>, _Graph>();
 		          checkConcept<MappableGraphComponent<>, _Graph>();
+		        }
 		      };
 		    };
+		  }
+		}
 		#endif

lemon/concepts/graph_components.h

Show inline comments

@@ -479,1024 +479,1036 @@
 		      template<typename _GraphItemIt>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<GraphItem<>, _GraphItemIt>();
 		          _GraphItemIt it1(g);
 		          _GraphItemIt it2;
 		          _GraphItemIt it3 = it1;
 		          _GraphItemIt it4 = INVALID;
 		          it2 = ++it1;
 		          ++it2 = it1;
 		          ++(++it1);
 		          Item bi = it1;
 		          bi = it2;
+		        }
 		        const GR& g;
 		      };
 		    };
 		    /// \brief Concept class for \c InArcIt, \c OutArcIt and
 		    /// \c IncEdgeIt types.
 		    ///
 		    /// This class describes the concept of \c InArcIt, \c OutArcIt
 		    /// and \c IncEdgeIt subtypes of digraph and graph types.
 		    ///
 		    /// \note Since these iterator classes do not inherit from the same
 		    /// base class, there is an additional template parameter (selector)
 		    /// \c sel. For \c InArcIt you should instantiate it with character
 		    /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
 		    template <typename GR,
 		              typename Item = typename GR::Arc,
 		              typename Base = typename GR::Node,
 		              char sel = '0'>
 		    class GraphIncIt : public Item {
 		    public:
 		      /// \brief Default constructor.
 		      ///
 		      /// Default constructor.
 		      /// \warning The default constructor is not required to set
 		      /// the iterator to some well-defined value. So you should consider it
 		      /// as uninitialized.
 		      GraphIncIt() {}
 		      /// \brief Copy constructor.
 		      ///
 		      /// Copy constructor.
 		      GraphIncIt(const GraphIncIt& it) : Item(it) {}
 		      /// \brief Constructor that sets the iterator to the first
 		      /// incoming or outgoing arc.
 		      ///
 		      /// Constructor that sets the iterator to the first arc
 		      /// incoming to or outgoing from the given node.
 		      explicit GraphIncIt(const GR&, const Base&) {}
 		      /// \brief Constructor for conversion from \c INVALID.
 		      ///
 		      /// Constructor for conversion from \c INVALID.
 		      /// It initializes the iterator to be invalid.
 		      /// \sa Invalid for more details.
 		      GraphIncIt(Invalid) {}
 		      /// \brief Assignment operator.
 		      ///
 		      /// Assignment operator for the iterator.
 		      GraphIncIt& operator=(const GraphIncIt&) { return *this; }
 		      /// \brief Increment the iterator.
 		      ///
 		      /// This operator increments the iterator, i.e. assigns it to the
 		      /// next arc incoming to or outgoing from the given node.
 		      GraphIncIt& operator++() { return *this; }
 		      /// \brief Equality operator
 		      ///
 		      /// Equality operator.
 		      /// Two iterators are equal if and only if they point to the
 		      /// same object or both are invalid.
 		      bool operator==(const GraphIncIt&) const { return true;}
 		      /// \brief Inequality operator
 		      ///
 		      /// Inequality operator.
 		      /// Two iterators are equal if and only if they point to the
 		      /// same object or both are invalid.
 		      bool operator!=(const GraphIncIt&) const { return true;}
 		      template <typename _GraphIncIt>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<GraphItem<sel>, _GraphIncIt>();
 		          _GraphIncIt it1(graph, node);
 		          _GraphIncIt it2;
 		          _GraphIncIt it3 = it1;
 		          _GraphIncIt it4 = INVALID;
 		          it2 = ++it1;
 		          ++it2 = it1;
 		          ++(++it1);
 		          Item e = it1;
 		          e = it2;
+		        }
 		        const Base& node;
 		        const GR& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for iterable directed graphs.
 		    ///
 		    /// This class describes the interface of iterable directed
 		    /// graphs. It extends \ref BaseDigraphComponent with the core
 		    /// iterable interface.
 		    /// This concept is part of the Digraph concept.
 		    template <typename BAS = BaseDigraphComponent>
 		    class IterableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      typedef IterableDigraphComponent Digraph;
 		      /// \name Base iteration
 		      ///
 		      /// This interface provides functions for iteration on digraph items.
 		      ///
 		      /// @{
 		      /// \brief Return the first node.
 		      ///
 		      /// This function gives back the first node in the iteration order.
 		      void first(Node&) const {}
 		      /// \brief Return the next node.
 		      ///
 		      /// This function gives back the next node in the iteration order.
 		      void next(Node&) const {}
 		      /// \brief Return the first arc.
 		      ///
 		      /// This function gives back the first arc in the iteration order.
 		      void first(Arc&) const {}
 		      /// \brief Return the next arc.
 		      ///
 		      /// This function gives back the next arc in the iteration order.
 		      void next(Arc&) const {}
 		      /// \brief Return the first arc incomming to the given node.
 		      ///
 		      /// This function gives back the first arc incomming to the
 		      /// given node.
 		      void firstIn(Arc&, const Node&) const {}
 		      /// \brief Return the next arc incomming to the given node.
 		      ///
 		      /// This function gives back the next arc incomming to the
 		      /// given node.
 		      void nextIn(Arc&) const {}
 		      /// \brief Return the first arc outgoing form the given node.
 		      ///
 		      /// This function gives back the first arc outgoing form the
 		      /// given node.
 		      void firstOut(Arc&, const Node&) const {}
 		      /// \brief Return the next arc outgoing form the given node.
 		      ///
 		      /// This function gives back the next arc outgoing form the
 		      /// given node.
 		      void nextOut(Arc&) const {}
 		      /// @}
 		      /// \name Class based iteration
 		      ///
 		      /// This interface provides iterator classes for digraph items.
 		      ///
 		      /// @{
 		      /// \brief This iterator goes through each node.
 		      ///
 		      /// This iterator goes through each node.
 		      ///
 		      typedef GraphItemIt<Digraph, Node> NodeIt;
 		      /// \brief This iterator goes through each arc.
 		      ///
 		      /// This iterator goes through each arc.
 		      ///
 		      typedef GraphItemIt<Digraph, Arc> ArcIt;
 		      /// \brief This iterator goes trough the incoming arcs of a node.
 		      ///
 		      /// This iterator goes trough the \e incoming arcs of a certain node
 		      /// of a digraph.
 		      typedef GraphIncIt<Digraph, Arc, Node, 'i'> InArcIt;
 		      /// \brief This iterator goes trough the outgoing arcs of a node.
 		      ///
 		      /// This iterator goes trough the \e outgoing arcs of a certain node
 		      /// of a digraph.
 		      typedef GraphIncIt<Digraph, Arc, Node, 'o'> OutArcIt;
 		      /// \brief The base node of the iterator.
 		      ///
 		      /// This function gives back the base node of the iterator.
 		      /// It is always the target node of the pointed arc.
 		      Node baseNode(const InArcIt&) const { return INVALID; }
 		      /// \brief The running node of the iterator.
 		      ///
 		      /// This function gives back the running node of the iterator.
 		      /// It is always the source node of the pointed arc.
 		      Node runningNode(const InArcIt&) const { return INVALID; }
 		      /// \brief The base node of the iterator.
 		      ///
 		      /// This function gives back the base node of the iterator.
 		      /// It is always the source node of the pointed arc.
 		      Node baseNode(const OutArcIt&) const { return INVALID; }
 		      /// \brief The running node of the iterator.
 		      ///
 		      /// This function gives back the running node of the iterator.
 		      /// It is always the target node of the pointed arc.
 		      Node runningNode(const OutArcIt&) const { return INVALID; }
 		      /// @}
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
+		          {
 		            typename _Digraph::Node node(INVALID);
 		            typename _Digraph::Arc arc(INVALID);
+		            {
 		              digraph.first(node);
 		              digraph.next(node);
+		            }
+		            {
 		              digraph.first(arc);
 		              digraph.next(arc);
+		            }
+		            {
 		              digraph.firstIn(arc, node);
 		              digraph.nextIn(arc);
+		            }
+		            {
 		              digraph.firstOut(arc, node);
 		              digraph.nextOut(arc);
+		            }
+		          }
+		          {
 		            checkConcept<GraphItemIt<_Digraph, typename _Digraph::Arc>,
 		              typename _Digraph::ArcIt >();
 		            checkConcept<GraphItemIt<_Digraph, typename _Digraph::Node>,
 		              typename _Digraph::NodeIt >();
 		            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc,
 		              typename _Digraph::Node, 'i'>, typename _Digraph::InArcIt>();
 		            checkConcept<GraphIncIt<_Digraph, typename _Digraph::Arc,
 		              typename _Digraph::Node, 'o'>, typename _Digraph::OutArcIt>();
 		            typename _Digraph::Node n;
 		            const typename _Digraph::InArcIt iait(INVALID);
 		            const typename _Digraph::OutArcIt oait(INVALID);
 		            n = digraph.baseNode(iait);
 		            n = digraph.runningNode(iait);
 		            n = digraph.baseNode(oait);
 		            n = digraph.runningNode(oait);
 		            ignore_unused_variable_warning(n);
+		          }
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for iterable undirected graphs.
 		    ///
 		    /// This class describes the interface of iterable undirected
 		    /// graphs. It extends \ref IterableDigraphComponent with the core
 		    /// iterable interface of undirected graphs.
 		    /// This concept is part of the Graph concept.
 		    template <typename BAS = BaseGraphComponent>
 		    class IterableGraphComponent : public IterableDigraphComponent<BAS> {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      typedef typename Base::Edge Edge;
 		      typedef IterableGraphComponent Graph;
 		      /// \name Base iteration
 		      ///
 		      /// This interface provides functions for iteration on edges.
 		      ///
 		      /// @{
 		      using IterableDigraphComponent<Base>::first;
 		      using IterableDigraphComponent<Base>::next;
 		      /// \brief Return the first edge.
 		      ///
 		      /// This function gives back the first edge in the iteration order.
 		      void first(Edge&) const {}
 		      /// \brief Return the next edge.
 		      ///
 		      /// This function gives back the next edge in the iteration order.
 		      void next(Edge&) const {}
 		      /// \brief Return the first edge incident to the given node.
 		      ///
 		      /// This function gives back the first edge incident to the given
 		      /// node. The bool parameter gives back the direction for which the
 		      /// source node of the directed arc representing the edge is the
 		      /// given node.
 		      void firstInc(Edge&, bool&, const Node&) const {}
 		      /// \brief Gives back the next of the edges from the
 		      /// given node.
 		      ///
 		      /// This function gives back the next edge incident to the given
 		      /// node. The bool parameter should be used as \c firstInc() use it.
 		      void nextInc(Edge&, bool&) const {}
 		      using IterableDigraphComponent<Base>::baseNode;
 		      using IterableDigraphComponent<Base>::runningNode;
 		      /// @}
 		      /// \name Class based iteration
 		      ///
 		      /// This interface provides iterator classes for edges.
 		      ///
 		      /// @{
 		      /// \brief This iterator goes through each edge.
 		      ///
 		      /// This iterator goes through each edge.
 		      typedef GraphItemIt<Graph, Edge> EdgeIt;
 		      /// \brief This iterator goes trough the incident edges of a
 		      /// node.
 		      ///
 		      /// This iterator goes trough the incident edges of a certain
 		      /// node of a graph.
 		      typedef GraphIncIt<Graph, Edge, Node, 'e'> IncEdgeIt;
 		      /// \brief The base node of the iterator.
 		      ///
 		      /// This function gives back the base node of the iterator.
 		      Node baseNode(const IncEdgeIt&) const { return INVALID; }
 		      /// \brief The running node of the iterator.
 		      ///
 		      /// This function gives back the running node of the iterator.
 		      Node runningNode(const IncEdgeIt&) const { return INVALID; }
 		      /// @}
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<IterableDigraphComponent<Base>, _Graph>();
+		          {
 		            typename _Graph::Node node(INVALID);
 		            typename _Graph::Edge edge(INVALID);
 		            bool dir;
+		            {
 		              graph.first(edge);
 		              graph.next(edge);
+		            }
+		            {
 		              graph.firstInc(edge, dir, node);
 		              graph.nextInc(edge, dir);
+		            }
+		          }
+		          {
 		            checkConcept<GraphItemIt<_Graph, typename _Graph::Edge>,
 		              typename _Graph::EdgeIt >();
 		            checkConcept<GraphIncIt<_Graph, typename _Graph::Edge,
 		              typename _Graph::Node, 'e'>, typename _Graph::IncEdgeIt>();
 		            typename _Graph::Node n;
 		            const typename _Graph::IncEdgeIt ieit(INVALID);
 		            n = graph.baseNode(ieit);
 		            n = graph.runningNode(ieit);
+		          }
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for alterable directed graphs.
 		    ///
 		    /// This class describes the interface of alterable directed
 		    /// graphs. It extends \ref BaseDigraphComponent with the alteration
 		    /// notifier interface. It implements
 		    /// an observer-notifier pattern for each digraph item. More
 		    /// obsevers can be registered into the notifier and whenever an
 		    /// alteration occured in the digraph all the observers will be
 		    /// notified about it.
 		    template <typename BAS = BaseDigraphComponent>
 		    class AlterableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// Node alteration notifier class.
 		      typedef AlterationNotifier<AlterableDigraphComponent, Node>
 		      NodeNotifier;
 		      /// Arc alteration notifier class.
 		      typedef AlterationNotifier<AlterableDigraphComponent, Arc>
 		      ArcNotifier;
 		      /// \brief Return the node alteration notifier.
 		      ///
 		      /// This function gives back the node alteration notifier.
 		      NodeNotifier& notifier(Node) const {
 		         return NodeNotifier();
+		      }
 		      /// \brief Return the arc alteration notifier.
 		      ///
 		      /// This function gives back the arc alteration notifier.
 		      ArcNotifier& notifier(Arc) const {
 		        return ArcNotifier();
+		      }
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          typename _Digraph::NodeNotifier& nn
 		            = digraph.notifier(typename _Digraph::Node());
 		          typename _Digraph::ArcNotifier& en
 		            = digraph.notifier(typename _Digraph::Arc());
 		          ignore_unused_variable_warning(nn);
 		          ignore_unused_variable_warning(en);
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for alterable undirected graphs.
 		    ///
 		    /// This class describes the interface of alterable undirected
 		    /// graphs. It extends \ref AlterableDigraphComponent with the alteration
 		    /// notifier interface of undirected graphs. It implements
 		    /// an observer-notifier pattern for the edges. More
 		    /// obsevers can be registered into the notifier and whenever an
 		    /// alteration occured in the graph all the observers will be
 		    /// notified about it.
 		    template <typename BAS = BaseGraphComponent>
 		    class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Edge Edge;
 		      /// Edge alteration notifier class.
 		      typedef AlterationNotifier<AlterableGraphComponent, Edge>
 		      EdgeNotifier;
 		      /// \brief Return the edge alteration notifier.
 		      ///
 		      /// This function gives back the edge alteration notifier.
 		      EdgeNotifier& notifier(Edge) const {
 		        return EdgeNotifier();
+		      }
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<AlterableDigraphComponent<Base>, _Graph>();
 		          typename _Graph::EdgeNotifier& uen
 		            = graph.notifier(typename _Graph::Edge());
 		          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.
 		    /// The standard graph maps must conform to the ReferenceMap concept.
 		    template <typename GR, typename K, typename V>
-		    class GraphMap : public ReadWriteMap<K, V> {
+		    class GraphMap : public ReferenceMap<K, V, V&, const 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;
 		      /// The reference type of the map.
 		      typedef Value& Reference;
 		      /// The const reference type of the map.
 		      typedef const Value& ConstReference;
 		      // The reference map tag.
 		      typedef True ReferenceMapTag;
 		      /// \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.
 		      ///
 		      /// Copy Constructor.
 		      GraphMap(const GraphMap&) : Parent() {}
 		      /// \brief Assignment operator.
 		      ///
 		      /// Assignment operator. It does not mofify the underlying graph,
 		      /// 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() {
-		          checkConcept<ReadWriteMap<Key, Value>, _Map >();
 		          checkConcept
 		            <ReferenceMap<Key, Value, Value&, const Value&>, _Map>();
 		          _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);
 		          // ignore_unused_variable_warning(m3);
+		        }
 		        const _Map &m;
 		        const Graph &g;
 		        const typename GraphMap::Value &t;
 		      };
 		    };
 		    /// \brief Skeleton class for mappable directed graphs.
 		    ///
 		    /// This class describes the interface of mappable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with the standard digraph
 		    /// map classes, namely \c NodeMap and \c ArcMap.
 		    /// This concept is part of the Digraph concept.
 		    template <typename BAS = BaseDigraphComponent>
 		    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.
 		      /// It conforms to the ReferenceMap concept.
 		      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.
 		        ///
 		        /// Construct a new map for the digraph and initalize the values.
 		        NodeMap(const MappableDigraphComponent& digraph, const V& value)
 		          : Parent(digraph, value) {}
 		      private:
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy Constructor.
 		        NodeMap(const NodeMap& nm) : Parent(nm) {}
 		        /// \brief Assignment operator.
 		        ///
 		        /// 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.
 		      /// It conforms to the ReferenceMap concept.
 		      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.
 		        ///
 		        /// Construct a new map for the digraph and initalize the values.
 		        ArcMap(const MappableDigraphComponent& digraph, const V& value)
 		          : Parent(digraph, value) {}
 		      private:
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy Constructor.
 		        ArcMap(const ArcMap& nm) : Parent(nm) {}
 		        /// \brief Assignment operator.
 		        ///
 		        /// Assignment operator.
 		        template <typename CMap>
 		        ArcMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Arc, V>, CMap>();
 		          return *this;
+		        }
 		      };
 		      template <typename _Digraph>
 		      struct Constraints {
 		        struct Dummy {
 		          int value;
 		          Dummy() : value(0) {}
 		          Dummy(int _v) : value(_v) {}
 		        };
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          { // int map test
 		            typedef typename _Digraph::template NodeMap<int> IntNodeMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, int>,
 		              IntNodeMap >();
 		          } { // bool map test
 		            typedef typename _Digraph::template NodeMap<bool> BoolNodeMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, bool>,
 		              BoolNodeMap >();
 		          } { // Dummy map test
 		            typedef typename _Digraph::template NodeMap<Dummy> DummyNodeMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, Dummy>,
 		              DummyNodeMap >();
+		          }
 		          { // int map test
 		            typedef typename _Digraph::template ArcMap<int> IntArcMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, int>,
 		              IntArcMap >();
 		          } { // bool map test
 		            typedef typename _Digraph::template ArcMap<bool> BoolArcMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, bool>,
 		              BoolArcMap >();
 		          } { // Dummy map test
 		            typedef typename _Digraph::template ArcMap<Dummy> DummyArcMap;
 		            checkConcept<GraphMap<_Digraph, typename _Digraph::Arc, Dummy>,
 		              DummyArcMap >();
+		          }
+		        }
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for mappable undirected graphs.
 		    ///
 		    /// This class describes the interface of mappable undirected graphs.
 		    /// It extends \ref MappableDigraphComponent with the standard graph
 		    /// map class for edges (\c EdgeMap).
 		    /// This concept is part of the Graph concept.
 		    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.
 		      /// It conforms to the ReferenceMap concept.
 		      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.
 		        ///
 		        /// Construct a new map for the graph and initalize the values.
 		        EdgeMap(const MappableGraphComponent& graph, const V& value)
 		          : Parent(graph, value) {}
 		      private:
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy Constructor.
 		        EdgeMap(const EdgeMap& nm) : Parent(nm) {}
 		        /// \brief Assignment operator.
 		        ///
 		        /// Assignment operator.
 		        template <typename CMap>
 		        EdgeMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Edge, V>, CMap>();
 		          return *this;
+		        }
 		      };
 		      template <typename _Graph>
 		      struct Constraints {
 		        struct Dummy {
 		          int value;
 		          Dummy() : value(0) {}
 		          Dummy(int _v) : value(_v) {}
 		        };
 		        void constraints() {
 		          checkConcept<MappableDigraphComponent<Base>, _Graph>();
 		          { // int map test
 		            typedef typename _Graph::template EdgeMap<int> IntEdgeMap;
 		            checkConcept<GraphMap<_Graph, typename _Graph::Edge, int>,
 		              IntEdgeMap >();
 		          } { // bool map test
 		            typedef typename _Graph::template EdgeMap<bool> BoolEdgeMap;
 		            checkConcept<GraphMap<_Graph, typename _Graph::Edge, bool>,
 		              BoolEdgeMap >();
 		          } { // Dummy map test
 		            typedef typename _Graph::template EdgeMap<Dummy> DummyEdgeMap;
 		            checkConcept<GraphMap<_Graph, typename _Graph::Edge, Dummy>,
 		              DummyEdgeMap >();
+		          }
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for extendable directed graphs.
 		    ///
 		    /// This class describes the interface of extendable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with functions for adding
 		    /// nodes and arcs to the digraph.
 		    /// This concept requires \ref AlterableDigraphComponent.
 		    template <typename BAS = BaseDigraphComponent>
 		    class ExtendableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// \brief Add a new node to the digraph.
 		      ///
 		      /// This function adds a new node to the digraph.
 		      Node addNode() {
 		        return INVALID;
+		      }
 		      /// \brief Add a new arc connecting the given two nodes.
 		      ///
 		      /// This function adds a new arc connecting the given two nodes
 		      /// of the digraph.
 		      Arc addArc(const Node&, const Node&) {
 		        return INVALID;
+		      }
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          typename _Digraph::Node node_a, node_b;
 		          node_a = digraph.addNode();
 		          node_b = digraph.addNode();
 		          typename _Digraph::Arc arc;
 		          arc = digraph.addArc(node_a, node_b);
+		        }
 		        _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for extendable undirected graphs.
 		    ///
 		    /// This class describes the interface of extendable undirected graphs.
 		    /// It extends \ref BaseGraphComponent with functions for adding
 		    /// nodes and edges to the graph.
 		    /// This concept requires \ref AlterableGraphComponent.
 		    template <typename BAS = BaseGraphComponent>
 		    class ExtendableGraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Edge Edge;
 		      /// \brief Add a new node to the digraph.
 		      ///
 		      /// This function adds a new node to the digraph.
 		      Node addNode() {
 		        return INVALID;
+		      }
 		      /// \brief Add a new edge connecting the given two nodes.
 		      ///
 		      /// This function adds a new edge connecting the given two nodes
 		      /// of the graph.
 		      Edge addEdge(const Node&, const Node&) {
 		        return INVALID;
+		      }
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Graph>();
 		          typename _Graph::Node node_a, node_b;
 		          node_a = graph.addNode();
 		          node_b = graph.addNode();
 		          typename _Graph::Edge edge;
 		          edge = graph.addEdge(node_a, node_b);
+		        }
 		        _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for erasable directed graphs.
 		    ///
 		    /// This class describes the interface of erasable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with functions for removing
 		    /// nodes and arcs from the digraph.
 		    /// This concept requires \ref AlterableDigraphComponent.
 		    template <typename BAS = BaseDigraphComponent>
 		    class ErasableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// \brief Erase a node from the digraph.
 		      ///
 		      /// This function erases the given node from the digraph and all arcs
 		      /// connected to the node.
 		      void erase(const Node&) {}
 		      /// \brief Erase an arc from the digraph.
 		      ///
 		      /// This function erases the given arc from the digraph.
 		      void erase(const Arc&) {}
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          const typename _Digraph::Node node(INVALID);
 		          digraph.erase(node);
 		          const typename _Digraph::Arc arc(INVALID);
 		          digraph.erase(arc);
+		        }
 		        _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for erasable undirected graphs.
 		    ///
 		    /// This class describes the interface of erasable undirected graphs.
 		    /// It extends \ref BaseGraphComponent with functions for removing
 		    /// nodes and edges from the graph.
 		    /// This concept requires \ref AlterableGraphComponent.
 		    template <typename BAS = BaseGraphComponent>
 		    class ErasableGraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Edge Edge;
 		      /// \brief Erase a node from the graph.
 		      ///
 		      /// This function erases the given node from the graph and all edges
 		      /// connected to the node.
 		      void erase(const Node&) {}
 		      /// \brief Erase an edge from the digraph.
 		      ///
 		      /// This function erases the given edge from the digraph.
 		      void erase(const Edge&) {}
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Graph>();
 		          const typename _Graph::Node node(INVALID);
 		          graph.erase(node);
 		          const typename _Graph::Edge edge(INVALID);
 		          graph.erase(edge);
+		        }
 		        _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for clearable directed graphs.
 		    ///
 		    /// This class describes the interface of clearable directed graphs.
 		    /// It extends \ref BaseDigraphComponent with a function for clearing
 		    /// the digraph.
 		    /// This concept requires \ref AlterableDigraphComponent.
 		    template <typename BAS = BaseDigraphComponent>
 		    class ClearableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      /// \brief Erase all nodes and arcs from the digraph.
 		      ///
 		      /// This function erases all nodes and arcs from the digraph.
 		      void clear() {}
 		      template <typename _Digraph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Digraph>();
 		          digraph.clear();
+		        }
 		        _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for clearable undirected graphs.
 		    ///
 		    /// This class describes the interface of clearable undirected graphs.
 		    /// It extends \ref BaseGraphComponent with a function for clearing
 		    /// the graph.
 		    /// This concept requires \ref AlterableGraphComponent.
 		    template <typename BAS = BaseGraphComponent>
 		    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
 		    public:
 		      typedef BAS Base;
 		      /// \brief Erase all nodes and edges from the graph.
 		      ///
 		      /// This function erases all nodes and edges from the graph.
 		      void clear() {}
 		      template <typename _Graph>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept<Base, _Graph>();
 		          graph.clear();
+		        }
 		        _Graph& graph;
 		      };
 		    };
+		  }
+		}
 		#endif

0 comments (0 inline)

RhodeCode

Login to your account