lemon-main: comparison lemon/concepts/graph

equal deleted inserted replaced

-:d63de9c99019
+:048776b7e7aa
 ///\ingroup graph_concepts
 ///\file
 ///\brief The concept of graph components.
 #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 #define LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 #include <lemon/core.h>
 #include <lemon/concepts/maps.h>
 /// and Arc types should \em not derive from the same base class.
 /// For Node you should instantiate it with character 'n' and for Arc
 /// with 'a'.
 #ifndef DOXYGEN
-template <char _selector = '0'>
+template <char sel = '0'>
 #endif
 class GraphItem {
 public:
 /// \brief Default constructor.
 ///
 ///
 /// This class provides beside the core digraph features
 /// core id functions for the digraph structure.
 /// The most of the base digraphs should conform to this concept.
 /// The id's are unique and immutable.
-template <typename _Base = BaseDigraphComponent>
+template <typename BAS = BaseDigraphComponent>
-class IDableDigraphComponent : public _Base {
+class IDableDigraphComponent : public BAS {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Node Node;
 typedef typename Base::Arc Arc;
 /// \brief Gives back an unique integer id for the Node.
 ///
 ///
 /// This class provides beside the core undirected graph features
 /// core id functions for the undirected graph structure.  The
 /// most of the base undirected graphs should conform to this
 /// concept.  The id's are unique and immutable.
-template <typename _Base = BaseGraphComponent>
+template <typename BAS = BaseGraphComponent>
-class IDableGraphComponent : public IDableDigraphComponent<_Base> {
+class IDableGraphComponent : public IDableDigraphComponent<BAS> {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Edge Edge;
-using IDableDigraphComponent<_Base>::id;
+using IDableDigraphComponent<Base>::id;
 /// \brief Gives back an unique integer id for the Edge.
 ///
 /// Gives back an unique integer id for the Edge.
 ///
 /// \brief Skeleton class for graph NodeIt and ArcIt
 ///
 /// Skeleton class for graph NodeIt and ArcIt.
 ///
-template <typename _Graph, typename _Item>
+template <typename GR, typename Item>
-class GraphItemIt : public _Item {
+class GraphItemIt : public Item {
 public:
 /// \brief Default constructor.
 ///
 /// @warning The default constructor sets the iterator
 /// to an undefined value.
 GraphItemIt(const GraphItemIt& ) {}
 /// \brief Sets the iterator to the first item.
 ///
 /// Sets the iterator to the first item of \c the graph.
 ///
-explicit GraphItemIt(const _Graph&) {}
+explicit GraphItemIt(const GR&) {}
 /// \brief Invalid constructor \& conversion.
 ///
 /// This constructor initializes the item to be invalid.
 /// \sa Invalid for more details.
 GraphItemIt(Invalid) {}
 it2 = ++it1;
 ++it2 = it1;
 ++(++it1);
-_Item bi = it1;
+Item bi = it1;
 bi = it2;
 }
-_Graph& g;
+GR& g;
 };
 };
 /// \brief Skeleton class for graph InArcIt and OutArcIt
 ///
 /// \note Because InArcIt and OutArcIt may not inherit from the same
-/// base class, the _selector is a additional template parameter. For
+/// base class, the \c sel is a additional template parameter (selector).
-/// InArcIt you should instantiate it with character 'i' and for
+/// For InArcIt you should instantiate it with character 'i' and for
 /// OutArcIt with 'o'.
-template <typename _Graph,
+template <typename GR,
-typename _Item = typename _Graph::Arc,
+typename Item = typename GR::Arc,
-typename _Base = typename _Graph::Node,
+typename Base = typename GR::Node,
-char _selector = '0'>
+char sel = '0'>
-class GraphIncIt : public _Item {
+class GraphIncIt : public Item {
 public:
 /// \brief Default constructor.
 ///
 /// @warning The default constructor sets the iterator
 /// to an undefined value.
 GraphIncIt() {}
 /// \brief Copy constructor.
 ///
 /// Copy constructor.
 ///
-GraphIncIt(GraphIncIt const& gi) : _Item(gi) {}
+GraphIncIt(GraphIncIt const& gi) : Item(gi) {}
 /// \brief Sets the iterator to the first arc incoming into or outgoing
 /// from the node.
 ///
 /// Sets the iterator to the first arc incoming into or outgoing
 /// from the node.
 ///
-explicit GraphIncIt(const _Graph&, const _Base&) {}
+explicit GraphIncIt(const GR&, const Base&) {}
 /// \brief Invalid constructor \& conversion.
 ///
 /// This constructor initializes the item to be invalid.
 /// \sa Invalid for more details.
 GraphIncIt(Invalid) {}
 bool operator!=(const GraphIncIt&) const { return true;}
 template <typename _GraphIncIt>
 struct Constraints {
 void constraints() {
-checkConcept<GraphItem<_selector>, _GraphIncIt>();
+checkConcept<GraphItem<sel>, _GraphIncIt>();
 _GraphIncIt it1(graph, node);
 _GraphIncIt it2;
 it2 = ++it1;
 ++it2 = it1;
 ++(++it1);
-_Item e = it1;
+Item e = it1;
 e = it2;
 }
-_Item arc;
+Item arc;
-_Base node;
+Base node;
-_Graph graph;
+GR graph;
 _GraphIncIt it;
 };
 };
 /// \brief An empty iterable digraph class.
 ///
 /// This class provides beside the core digraph features
 /// iterator based iterable interface for the digraph structure.
 /// This concept is part of the Digraph concept.
-template <typename _Base = BaseDigraphComponent>
+template <typename BAS = BaseDigraphComponent>
-class IterableDigraphComponent : public _Base {
+class IterableDigraphComponent : public BAS {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Node Node;
 typedef typename Base::Arc Arc;
 typedef IterableDigraphComponent Digraph;
 /// \brief An empty iterable undirected graph class.
 ///
 /// This class provides beside the core graph features iterator
 /// based iterable interface for the undirected graph structure.
 /// This concept is part of the Graph concept.
-template <typename _Base = BaseGraphComponent>
+template <typename BAS = BaseGraphComponent>
-class IterableGraphComponent : public IterableDigraphComponent<_Base> {
+class IterableGraphComponent : public IterableDigraphComponent<BAS> {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Node Node;
 typedef typename Base::Arc Arc;
 typedef typename Base::Edge Edge;
 /// \name Base iteration
 ///
 /// This interface provides functions for iteration on graph items
 /// @{
-using IterableDigraphComponent<_Base>::first;
+using IterableDigraphComponent<Base>::first;
-using IterableDigraphComponent<_Base>::next;
+using IterableDigraphComponent<Base>::next;
 /// \brief Gives back the first edge in the iterating
 /// order.
 ///
 /// Gives back the first edge in the iterating order.
 /// Gives back the next of the edges from the given
 /// node. The bool parameter should be used as the \c firstInc()
 /// use it.
 void nextInc(Edge&, bool&) const {}
-using IterableDigraphComponent<_Base>::baseNode;
+using IterableDigraphComponent<Base>::baseNode;
-using IterableDigraphComponent<_Base>::runningNode;
+using IterableDigraphComponent<Base>::runningNode;
 /// @}
 /// \name Class based iteration
 ///
 n = graph.runningNode(ueit);
 }
 }
 const _Graph& graph;
 };
 };
 /// \brief An empty alteration notifier digraph class.
 ///
 /// notifier interface for the digraph structure.  This 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
 /// notified about it.
-template <typename _Base = BaseDigraphComponent>
+template <typename BAS = BaseDigraphComponent>
-class AlterableDigraphComponent : public _Base {
+class AlterableDigraphComponent : public BAS {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Node Node;
 typedef typename Base::Arc Arc;
 /// The node observer registry.
 /// notifier interface for the graph structure.  This implements
 /// an observer-notifier pattern for each graph item. More
 /// obsevers can be registered into the notifier and whenever an
 /// alteration occured in the graph all the observers will
 /// notified about it.
-template <typename _Base = BaseGraphComponent>
+template <typename BAS = BaseGraphComponent>
-class AlterableGraphComponent : public AlterableDigraphComponent<_Base> {
+class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Edge Edge;
 /// The arc observer registry.
 typedef AlterationNotifier<AlterableGraphComponent, Edge>
 = graph.notifier(typename _Graph::Edge());
 ignore_unused_variable_warning(uen);
 }
 const _Graph& graph;
+};
-};
 };
 /// \brief Class describing the concept of graph maps
 ///
 /// This class describes the common interface of the graph maps
 /// (NodeMap, ArcMap), that is maps that can be used to
 /// associate data to graph descriptors (nodes or arcs).
-template <typename _Graph, typename _Item, typename _Value>
+template <typename GR, typename K, typename V>
-class GraphMap : public ReadWriteMap<_Item, _Value> {
+class GraphMap : public ReadWriteMap<K, V> {
 public:
-typedef ReadWriteMap<_Item, _Value> Parent;
+typedef ReadWriteMap<K, V> Parent;
 /// The graph type of the map.
-typedef _Graph Graph;
+typedef GR Graph;
 /// The key type of the map.
-typedef _Item Key;
+typedef K Key;
 /// The value type of the map.
-typedef _Value Value;
+typedef V Value;
 /// \brief Construct a new map.
 ///
 /// Construct a new map for the graph.
 explicit GraphMap(const Graph&) {}
 /// \brief An empty mappable digraph class.
 ///
 /// This class provides beside the core digraph features
 /// map interface for the digraph structure.
 /// This concept is part of the Digraph concept.
-template <typename _Base = BaseDigraphComponent>
+template <typename BAS = BaseDigraphComponent>
-class MappableDigraphComponent : public _Base  {
+class MappableDigraphComponent : public BAS  {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Node Node;
 typedef typename Base::Arc Arc;
 typedef MappableDigraphComponent Digraph;
 /// \brief ReadWrite map of the nodes.
 ///
 /// ReadWrite map of the nodes.
 ///
-template <typename _Value>
+template <typename V>
-class NodeMap : public GraphMap<Digraph, Node, _Value> {
+class NodeMap : public GraphMap<Digraph, Node, V> {
 public:
-typedef GraphMap<MappableDigraphComponent, Node, _Value> Parent;
+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 initalise the values.
-NodeMap(const MappableDigraphComponent& digraph, const _Value& value)
+NodeMap(const MappableDigraphComponent& digraph, const V& value)
 : Parent(digraph, value) {}
 private:
 /// \brief Copy constructor.
 ///
 /// \brief Assign operator.
 ///
 /// Assign operator.
 template <typename CMap>
 NodeMap& operator=(const CMap&) {
-checkConcept<ReadMap<Node, _Value>, CMap>();
+checkConcept<ReadMap<Node, V>, CMap>();
 return *this;
 }
 };
 /// \brief ReadWrite map of the arcs.
 ///
 /// ReadWrite map of the arcs.
 ///
-template <typename _Value>
+template <typename V>
-class ArcMap : public GraphMap<Digraph, Arc, _Value> {
+class ArcMap : public GraphMap<Digraph, Arc, V> {
 public:
-typedef GraphMap<MappableDigraphComponent, Arc, _Value> Parent;
+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 initalise the values.
-ArcMap(const MappableDigraphComponent& digraph, const _Value& value)
+ArcMap(const MappableDigraphComponent& digraph, const V& value)
 : Parent(digraph, value) {}
 private:
 /// \brief Copy constructor.
 ///
 /// \brief Assign operator.
 ///
 /// Assign operator.
 template <typename CMap>
 ArcMap& operator=(const CMap&) {
-checkConcept<ReadMap<Arc, _Value>, CMap>();
+checkConcept<ReadMap<Arc, V>, CMap>();
 return *this;
 }
 };
 /// \brief An empty mappable base bipartite graph class.
 ///
 /// This class provides beside the core graph features
 /// map interface for the graph structure.
 /// This concept is part of the Graph concept.
-template <typename _Base = BaseGraphComponent>
+template <typename BAS = BaseGraphComponent>
-class MappableGraphComponent : public MappableDigraphComponent<_Base>  {
+class MappableGraphComponent : public MappableDigraphComponent<BAS>  {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Edge Edge;
 typedef MappableGraphComponent Graph;
 /// \brief ReadWrite map of the edges.
 ///
 /// ReadWrite map of the edges.
 ///
-template <typename _Value>
+template <typename V>
-class EdgeMap : public GraphMap<Graph, Edge, _Value> {
+class EdgeMap : public GraphMap<Graph, Edge, V> {
 public:
-typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
+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 initalise the values.
-EdgeMap(const MappableGraphComponent& graph, const _Value& value)
+EdgeMap(const MappableGraphComponent& graph, const V& value)
 : Parent(graph, value) {}
 private:
 /// \brief Copy constructor.
 ///
 /// \brief Assign operator.
 ///
 /// Assign operator.
 template <typename CMap>
 EdgeMap& operator=(const CMap&) {
-checkConcept<ReadMap<Edge, _Value>, CMap>();
+checkConcept<ReadMap<Edge, V>, CMap>();
 return *this;
 }
 };
 ///
 /// This class provides beside the core digraph features digraph
 /// extendable interface for the digraph structure.  The main
 /// difference between the base and this interface is that the
 /// digraph alterations should handled already on this level.
-template <typename _Base = BaseDigraphComponent>
+template <typename BAS = BaseDigraphComponent>
-class ExtendableDigraphComponent : public _Base {
+class ExtendableDigraphComponent : public BAS {
 public:
-typedef _Base Base;
+typedef BAS Base;
-typedef typename _Base::Node Node;
+typedef typename Base::Node Node;
-typedef typename _Base::Arc Arc;
+typedef typename Base::Arc Arc;
 /// \brief Adds a new node to the digraph.
 ///
 /// Adds a new node to the digraph.
 ///
 /// This class provides beside the core undirected graph features
 /// core undircted graph extend interface for the graph structure.
 /// The main difference between the base and this interface is
 /// that the graph alterations should handled already on this
 /// level.
-template <typename _Base = BaseGraphComponent>
+template <typename BAS = BaseGraphComponent>
-class ExtendableGraphComponent : public _Base {
+class ExtendableGraphComponent : public BAS {
 public:
-typedef _Base Base;
+typedef BAS Base;
-typedef typename _Base::Node Node;
+typedef typename Base::Node Node;
-typedef typename _Base::Edge Edge;
+typedef typename Base::Edge Edge;
 /// \brief Adds a new node to the graph.
 ///
 /// Adds a new node to the graph.
 ///
 ///
 /// This class provides beside the core digraph features core erase
 /// functions for the digraph structure. The main difference between
 /// the base and this interface is that the digraph alterations
 /// should handled already on this level.
-template <typename _Base = BaseDigraphComponent>
+template <typename BAS = BaseDigraphComponent>
-class ErasableDigraphComponent : public _Base {
+class ErasableDigraphComponent : public BAS {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Node Node;
 typedef typename Base::Arc Arc;
 /// \brief Erase a node from the digraph.
 ///
 ///
 /// This class provides beside the core undirected graph features
 /// core erase functions for the undirceted graph structure. The
 /// main difference between the base and this interface is that
 /// the graph alterations should handled already on this level.
-template <typename _Base = BaseGraphComponent>
+template <typename BAS = BaseGraphComponent>
-class ErasableGraphComponent : public _Base {
+class ErasableGraphComponent : public BAS {
 public:
-typedef _Base Base;
+typedef BAS Base;
 typedef typename Base::Node Node;
 typedef typename Base::Edge Edge;
 /// \brief Erase a node from the graph.
 ///
 ///
 /// This class provides beside the core digraph features core clear
 /// functions for the digraph structure. The main difference between
 /// the base and this interface is that the digraph alterations
 /// should handled already on this level.
-template <typename _Base = BaseDigraphComponent>
+template <typename BAS = BaseDigraphComponent>
-class ClearableDigraphComponent : public _Base {
+class ClearableDigraphComponent : public BAS {
 public:
-typedef _Base Base;
+typedef BAS Base;
 /// \brief Erase all nodes and arcs from the digraph.
 ///
 /// Erase all nodes and arcs from the digraph.
 ///
 ///
 /// This class provides beside the core undirected graph features
 /// core clear functions for the undirected graph structure. The
 /// main difference between the base and this interface is that
 /// the graph alterations should handled already on this level.
-template <typename _Base = BaseGraphComponent>
+template <typename BAS = BaseGraphComponent>
-class ClearableGraphComponent : public ClearableDigraphComponent<_Base> {
+class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
 public:
-typedef _Base Base;
+typedef BAS Base;
 template <typename _Graph>
 struct Constraints {
 void constraints() {
 checkConcept<ClearableGraphComponent<Base>, _Graph>();

changeset 563	dad9db81ade2
parent 534	6d3a9eec82b4
child 579	d11bf7998905