Changeset 2260:4274224f8a7d in lemon-0.x

Timestamp:

10/24/06 19:19:16 (17 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3016

Message:

concept -> concepts (namespace & directory)

Files:

• Makefile.am (modified) (1 diff)
• doc/graphs.dox (modified) (3 diffs)
• doc/groups.dox (modified) (2 diffs)
• doc/maps.dox (modified) (1 diff)
• doc/namespaces.dox (modified) (1 diff)
• lemon/Makefile.am (modified) (1 diff)
• lemon/bellman_ford.h (modified) (9 diffs)
• lemon/bfs.h (modified) (8 diffs)
• lemon/bits/array_map.h (modified) (2 diffs)
• lemon/bits/base_extender.h (modified) (1 diff)
• lemon/bits/debug_map.h (modified) (2 diffs)
• lemon/bits/graph_extender.h (modified) (2 diffs)
• lemon/bits/map_extender.h (modified) (2 diffs)
• lemon/bits/vector_map.h (modified) (2 diffs)
• lemon/color.h (modified) (1 diff)
• lemon/concept/bpugraph.h (deleted)
• lemon/concept/graph.h (deleted)
• lemon/concept/graph_components.h (deleted)
• lemon/concept/heap.h (deleted)
• lemon/concept/maps.h (deleted)
• lemon/concept/matrix_maps.h (deleted)
• lemon/concept/path.h (deleted)
• lemon/concept/ugraph.h (deleted)
• lemon/concepts/bpugraph.h (added)
• lemon/concepts/graph.h (added)
• lemon/concepts/graph_components.h (added)
• lemon/concepts/heap.h (added)
• lemon/concepts/maps.h (added)
• lemon/concepts/matrix_maps.h (added)
• lemon/concepts/path.h (added)
• lemon/concepts/ugraph.h (added)
• lemon/dag_shortest_path.h (modified) (12 diffs)
• lemon/dfs.h (modified) (9 diffs)
• lemon/dijkstra.h (modified) (10 diffs)
• lemon/edge_set.h (modified) (4 diffs)
• lemon/floyd_warshall.h (modified) (5 diffs)
• lemon/fredman_tarjan.h (modified) (6 diffs)
• lemon/full_graph.h (modified) (2 diffs)
• lemon/graph_adaptor.h (modified) (1 diff)
• lemon/grid_ugraph.h (modified) (1 diff)
• lemon/hypercube_graph.h (modified) (1 diff)
• lemon/johnson.h (modified) (5 diffs)
• lemon/kruskal.h (modified) (2 diffs)
• lemon/lemon_reader.h (modified) (5 diffs)
• lemon/lemon_writer.h (modified) (5 diffs)
• lemon/list_graph.h (modified) (4 diffs)
• lemon/lp_base.h (modified) (2 diffs)
• lemon/maps.h (modified) (23 diffs)
• lemon/matrix_maps.h (modified) (6 diffs)
• lemon/min_cost_arborescence.h (modified) (3 diffs)
• lemon/min_cut.h (modified) (6 diffs)
• lemon/prim.h (modified) (7 diffs)
• lemon/smart_graph.h (modified) (3 diffs)
• lemon/topology.h (modified) (21 diffs)
• lemon/vmap.h (modified) (3 diffs)
• test/bfs_test.cc (modified) (5 diffs)
• test/bpugraph_test.cc (modified) (2 diffs)
• test/dfs_test.cc (modified) (5 diffs)
• test/dijkstra_test.cc (modified) (6 diffs)
• test/edge_set_test.cc (modified) (2 diffs)
• test/graph_adaptor_test.cc (modified) (2 diffs)
• test/graph_factory_test.cc (modified) (5 diffs)
• test/graph_test.cc (modified) (2 diffs)
• test/heap_test.cc (modified) (2 diffs)
• test/kruskal_test.cc (modified) (2 diffs)
• test/maps_test.cc (modified) (2 diffs)
• test/matrix_maps_test.cc (modified) (2 diffs)
• test/path_test.cc (modified) (2 diffs)
• test/preflow_test.cc (modified) (2 diffs)
• test/test_tools.h (modified) (1 diff)
• test/ugraph_test.cc (modified) (2 diffs)

Makefile.am

@@ -14 +14 @@
 lemondir = $(pkgincludedir)
 bitsdir = $(lemondir)/bits
-conceptdir = $(lemondir)/concept
+conceptdir = $(lemondir)/concepts
 pkgconfig_DATA =
 lib_LTLIBRARIES =

doc/graphs.dox

@@ -12 +12 @@
 as  incoming and outgoing edges of a given node. 
 
-Each graph should meet the \ref lemon::concept::Graph "Graph" concept.
+Each graph should meet the \ref lemon::concepts::Graph "Graph" concept.
 This concept does not make it possible to change the graph (i.e. it is
 not possible to add or delete edges or nodes). Most of the graph
@@ -19 +19 @@
 
 In case of graphs meeting the full feature
-\ref lemon::concept::ErasableGraph "ErasableGraph"
+\ref lemon::concepts::ErasableGraph "ErasableGraph"
 concept
 you can also erase individual edges and nodes in arbitrary order.
@@ -25 +25 @@
 The implemented graph structures are the following.
 \li \ref lemon::ListGraph "ListGraph" is the most versatile graph class. It meets
-the \ref lemon::concept::ErasableGraph "ErasableGraph" concept
+the \ref lemon::concepts::ErasableGraph "ErasableGraph" concept
 and it also has some convenient extra features.
 \li \ref lemon::SmartGraph "SmartGraph" is a more memory
 efficient version of \ref lemon::ListGraph "ListGraph". The
 price of this is that it only meets the
-\ref lemon::concept::ExtendableGraph "ExtendableGraph" concept,
+\ref lemon::concepts::ExtendableGraph "ExtendableGraph" concept,
 so you cannot delete individual edges or nodes.
 \li \ref lemon::FullGraph "FullGraph"
 implements a complete graph. It is a
-\ref lemon::concept::Graph "Graph", so you cannot
+\ref lemon::concepts::Graph "Graph", so you cannot
 change the number of nodes once it is constructed. It is extremely memory
 efficient: it uses constant amount of memory independently from the number of

doc/groups.dox

@@ -77 +77 @@
 Map adaptors are used to create "implicit" maps from other maps.
 
-Most of them are \ref lemon::concept::ReadMap "ReadMap"s. They can
+Most of them are \ref lemon::concepts::ReadMap "ReadMap"s. They can
 make arithmetic operations between one or two maps (negation, scaling,
 addition, multiplication etc.) or e.g. convert a map to another one
@@ -103 +103 @@
 algorithm to store its result in any kind of path structure.
 
-\sa lemon::concept::Path
+\sa lemon::concepts::Path
 
 */

doc/maps.dox

@@ -14 +14 @@
 
 A map can be 
-\e readable (\ref lemon::concept::ReadMap "ReadMap", for short),
-\e writable (\ref lemon::concept::WriteMap "WriteMap") or both
-(\ref lemon::concept::ReadWriteMap "ReadWriteMap").
+\e readable (\ref lemon::concepts::ReadMap "ReadMap", for short),
+\e writable (\ref lemon::concepts::WriteMap "WriteMap") or both
+(\ref lemon::concepts::ReadWriteMap "ReadWriteMap").
 There also exists a special type of
-ReadWrite map called \ref lemon::concept::ReferenceMap "reference map".
+ReadWrite map called \ref lemon::concepts::ReferenceMap "reference map".
 In addition that you can
 read and write the values of a key, a reference map

doc/namespaces.dox

@@ -9 +9 @@
   /// The namespace of LEMON concepts and concept checking classes
   ///
-  namespace concept {}
+  namespace concepts {}
 }

lemon/Makefile.am

@@ -122 +122 @@
 concept_HEADERS += \
         lemon/concept_check.h \
-        lemon/concept/bpugraph.h \
-        lemon/concept/graph.h \
-        lemon/concept/graph_components.h \
-        lemon/concept/heap.h \
-        lemon/concept/maps.h \
-        lemon/concept/matrix_maps.h \
-        lemon/concept/path.h \
-        lemon/concept/ugraph.h
+        lemon/concepts/bpugraph.h \
+        lemon/concepts/graph.h \
+        lemon/concepts/graph_components.h \
+        lemon/concepts/heap.h \
+        lemon/concepts/maps.h \
+        lemon/concepts/matrix_maps.h \
+        lemon/concepts/path.h \
+        lemon/concepts/ugraph.h

lemon/bellman_ford.h

@@ -93 +93 @@
     ///
     /// The type of the map that stores the edge lengths.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _LengthMap LengthMap;
 
@@ -111 +111 @@
     /// The type of the map that stores the last
     /// edges of the shortest paths.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename _Graph::Edge> PredMap;
@@ -126 +126 @@
     ///
     /// The type of the map that stores the dists of the nodes.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename _LengthMap::Value> 
@@ -147 +147 @@
   /// This class provides an efficient implementation of \c Bellman-Ford 
   /// algorithm. The edge lengths are passed to the algorithm using a
-  /// \ref concept::ReadMap "ReadMap", so it is easy to change it to any 
+  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
   /// kind of length.
   ///
@@ -159 +159 @@
   ///
   /// The type of the length is determined by the
-  /// \ref concept::ReadMap::Value "Value" of the length map.
+  /// \ref concepts::ReadMap::Value "Value" of the length map.
   ///
   /// \param _Graph The graph type the algorithm runs on. The default value
@@ -165 +165 @@
   /// BellmanFord, it is only passed to \ref BellmanFordDefaultTraits.
   /// \param _LengthMap This read-only EdgeMap determines the lengths of the
-  /// edges. The default map type is \ref concept::Graph::EdgeMap 
+  /// edges. The default map type is \ref concepts::Graph::EdgeMap 
   /// "Graph::EdgeMap<int>".  The value of _LengthMap is not used directly 
   /// by BellmanFord, it is only passed to \ref BellmanFordDefaultTraits.  
@@ -791 +791 @@
     ///
     /// The type of the map that stores the edge lengths.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _LengthMap LengthMap;
 
@@ -809 +809 @@
     /// The type of the map that stores the last
     /// edges of the shortest paths.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap <typename _Graph::Node,typename _Graph::Edge> PredMap;
 
@@ -821 +821 @@
     ///
     /// The type of the map that stores the dists of the nodes.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Graph::Node, Value> DistMap;
     /// \brief Instantiates a DistMap.

lemon/bfs.h

@@ -48 +48 @@
     ///The type of the map that stores the last
     ///edges of the shortest paths.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename GR::Edge> PredMap;
@@ -63 +63 @@
  
     ///The type of the map that indicates which nodes are processed.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///\todo named parameter to set this type, function to read and write.
     typedef NullMap<typename Graph::Node,bool> ProcessedMap;
@@ -82 +82 @@
  
     ///The type of the map that indicates which nodes are reached.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///\todo named parameter to set this type, function to read and write.
     typedef typename Graph::template NodeMap<bool> ReachedMap;
@@ -97 +97 @@
  
     ///The type of the map that stores the dists of the nodes.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<int> DistMap;
@@ -706 +706 @@
     ///The type of the map that stores the last
     ///edges of the shortest paths.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef NullMap<typename Graph::Node,typename GR::Edge> PredMap;
@@ -726 +726 @@
  
     ///The type of the map that indicates which nodes are processed.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///\todo named parameter to set this type, function to read and write.
     typedef NullMap<typename Graph::Node,bool> ProcessedMap;
@@ -745 +745 @@
  
     ///The type of the map that indicates which nodes are reached.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///\todo named parameter to set this type, function to read and write.
     typedef typename Graph::template NodeMap<bool> ReachedMap;
@@ -760 +760 @@
  
     ///The type of the map that stores the dists of the nodes.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef NullMap<typename Graph::Node,int> DistMap;

lemon/bits/array_map.h

@@ -25 +25 @@
 #include <lemon/bits/alteration_notifier.h>
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 
 /// \ingroup graphbits
@@ -142 +142 @@
     template <typename CMap>
     ArrayMap& operator=(const CMap& cmap) {
-      checkConcept<concept::ReadMap<Key, _Value>, CMap>();
+      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
       const typename Parent::Notifier* notifier = Parent::getNotifier();
       Item it;

lemon/bits/base_extender.h

@@ -27 +27 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 
 ///\ingroup graphbits

lemon/bits/debug_map.h

@@ -30 +30 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 
 ///\ingroup graphbits
@@ -187 +187 @@
     template <typename CMap>
     DebugMap& operator=(const CMap& cmap) {
-      checkConcept<concept::ReadMap<Key, _Value>, CMap>();
+      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
       const typename Parent::Notifier* notifier = Parent::getNotifier();
       Item it;

lemon/bits/graph_extender.h

@@ -27 +27 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 
 ///\ingroup graphbits
@@ -1129 +1129 @@
       template <typename CMap>
       NodeMap& operator=(const CMap& cmap) {
-        checkConcept<concept::ReadMap<Node, _Value>, CMap>();
+        checkConcept<concepts::ReadMap<Node, _Value>, CMap>();
         aNodeMap = cmap;
         bNodeMap = cmap;

lemon/bits/map_extender.h

@@ -25 +25 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 
 ///\file
@@ -207 +207 @@
     template <typename CMap>
     SubMapExtender& operator=(const CMap& cmap) {
-      checkConcept<concept::ReadMap<Key, Value>, CMap>();
+      checkConcept<concepts::ReadMap<Key, Value>, CMap>();
       Item it;
       for (graph.first(it); it != INVALID; graph.next(it)) {

lemon/bits/vector_map.h

@@ -29 +29 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 
 ///\ingroup graphbits
@@ -134 +134 @@
     template <typename CMap>
     VectorMap& operator=(const CMap& cmap) {
-      checkConcept<concept::ReadMap<Key, _Value>, CMap>();
+      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
       const typename Parent::Notifier* notifier = Parent::getNotifier();
       Item it;

lemon/color.h

@@ -101 +101 @@
 ///number. The integer range is cyclically mapped to the provided set of colors.
 ///
-///This is a true \ref concept::ReferenceMap "reference map", so you can also
+///This is a true \ref concepts::ReferenceMap "reference map", so you can also
 ///change the actual colors.
 

lemon/dag_shortest_path.h

@@ -94 +94 @@
     ///
     /// The type of the map that stores the edge lengths.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _LengthMap LengthMap;
 
@@ -112 +112 @@
     /// The type of the map that stores the last
     /// edges of the shortest paths.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename _Graph::Edge> PredMap;
@@ -129 +129 @@
     ///
     /// The type of the map that stores the dists of the nodes.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename _LengthMap::Value> 
@@ -206 +206 @@
     ///
     /// The type of the map that stores the edge lengths.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _LengthMap LengthMap;
 
@@ -224 +224 @@
     /// The type of the map that stores the last
     /// edges of the longest paths.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename _Graph::Edge> PredMap;
@@ -241 +241 @@
     ///
     /// The type of the map that stores the dists of the nodes.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename _LengthMap::Value> 
@@ -263 +263 @@
   /// This class provides an efficient implementation of a Dag sortest path
   /// searching algorithm. The edge lengths are passed to the algorithm
-  /// using a \ref concept::ReadMap "ReadMap", so it is easy to change it
+  /// using a \ref concepts::ReadMap "ReadMap", so it is easy to change it
   /// to any kind of length.
   ///
@@ -269 +269 @@
   ///
   /// The type of the length is determined by the
-  /// \ref concept::ReadMap::Value "Value" of the length map.
+  /// \ref concepts::ReadMap::Value "Value" of the length map.
   ///
   /// \param _Graph The graph type the algorithm runs on. The default value
@@ -275 +275 @@
   /// DagShortestPath, it is only passed to \ref DagShortestPathDefaultTraits.
   /// \param _LengthMap This read-only EdgeMap determines the lengths of the
-  /// edges. The default map type is \ref concept::Graph::EdgeMap 
+  /// edges. The default map type is \ref concepts::Graph::EdgeMap 
   /// "Graph::EdgeMap<int>".  The value of _LengthMap is not used directly 
   /// by DagShortestPath, it is only passed to \ref DagShortestPathDefaultTraits.  
@@ -812 +812 @@
     ///
     /// The type of the map that stores the edge lengths.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _LengthMap LengthMap;
 
@@ -830 +830 @@
     /// The type of the map that stores the last
     /// edges of the shortest paths.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap <typename _Graph::Node,typename _Graph::Edge> PredMap;
 
@@ -842 +842 @@
     ///
     /// The type of the map that stores the dists of the nodes.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Graph::Node, Value> DistMap;
     /// \brief Instantiates a DistMap.

lemon/dfs.h

@@ -49 +49 @@
     ///The type of the map that stores the last
     ///edges of the %DFS paths.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename GR::Edge> PredMap;
@@ -65 +65 @@
  
     ///The type of the map that indicates which nodes are processed.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///\todo named parameter to set this type, function to read and write.
     typedef NullMap<typename Graph::Node,bool> ProcessedMap;
@@ -84 +84 @@
  
     ///The type of the map that indicates which nodes are reached.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///\todo named parameter to set this type, function to read and write.
     typedef typename Graph::template NodeMap<bool> ReachedMap;
@@ -99 +99 @@
  
     ///The type of the map that stores the dists of the nodes.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<int> DistMap;
@@ -753 +753 @@
     ///The type of the map that stores the last
     ///edges of the %DFS paths.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef NullMap<typename Graph::Node,typename GR::Edge> PredMap;
@@ -773 +773 @@
  
     ///The type of the map that indicates which nodes are processed.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///\todo named parameter to set this type, function to read and write.
     typedef NullMap<typename Graph::Node,bool> ProcessedMap;
@@ -792 +792 @@
  
     ///The type of the map that indicates which nodes are reached.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///\todo named parameter to set this type, function to read and write.
     typedef typename Graph::template NodeMap<bool> ReachedMap;
@@ -807 +807 @@
  
     ///The type of the map that stores the dists of the nodes.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef NullMap<typename Graph::Node,int> DistMap;
@@ -1169 +1169 @@
     /// 
     /// The type of the map that indicates which nodes are reached.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     /// \todo named parameter to set this type, function to read and write.
     typedef typename Graph::template NodeMap<bool> ReachedMap;

lemon/dijkstra.h

@@ -49 +49 @@
 
     ///The type of the map that stores the edge lengths.
-    ///It must meet the \ref concept::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LM LengthMap;
     //The type of the length of the edges.
@@ -87 +87 @@
     ///The type of the map that stores the last
     ///edges of the shortest paths.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename GR::Edge> PredMap;
@@ -103 +103 @@
  
     ///The type of the map that stores whether a nodes is processed.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     ///\todo If it is set to a real map,
@@ -125 +125 @@
  
     ///The type of the map that stores the dists of the nodes.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename Graph::template NodeMap<typename LM::Value> DistMap;
@@ -143 +143 @@
   ///This class provides an efficient implementation of %Dijkstra algorithm.
   ///The edge lengths are passed to the algorithm using a
-  ///\ref concept::ReadMap "ReadMap",
+  ///\ref concepts::ReadMap "ReadMap",
   ///so it is easy to change it to any kind of length.
   ///
   ///The type of the length is determined by the
-  ///\ref concept::ReadMap::Value "Value" of the length map.
+  ///\ref concepts::ReadMap::Value "Value" of the length map.
   ///
   ///It is also possible to change the underlying priority heap.
@@ -158 +158 @@
   ///relatively time consuming process to compute the edge length if
   ///it is necessary. The default map type is \ref
-  ///concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
+  ///concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   ///of LM is not used directly by Dijkstra, it is only passed to \ref
   ///DijkstraDefaultTraits.  \param TR Traits class to set
@@ -820 +820 @@
 
     ///The type of the map that stores the edge lengths.
-    ///It must meet the \ref concept::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LM LengthMap;
     //The type of the length of the edges.
@@ -862 +862 @@
     ///The type of the map that stores the last
     ///edges of the shortest paths.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef NullMap <typename GR::Node,typename GR::Edge> PredMap;
@@ -881 +881 @@
  
     ///The type of the map that stores whether a nodes is processed.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     ///\todo If it is set to a real map,
@@ -903 +903 @@
  
     ///The type of the map that stores the dists of the nodes.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef NullMap<typename Graph::Node,typename LM::Value> DistMap;

lemon/edge_set.h

@@ -239 +239 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref concept::Graph
+  /// this class. Its interface must conform to the \ref concepts::Graph
   /// "Graph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref concept::Graph "Graph" concept.
+  /// \ref concepts::Graph "Graph" concept.
   template <typename _Graph>
   class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<_Graph> > {
@@ -331 +331 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref concept::Graph
+  /// this class. Its interface must conform to the \ref concepts::Graph
   /// "Graph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref concept::UGraph "UGraph" concept.
+  /// \ref concepts::UGraph "UGraph" concept.
   template <typename _Graph>
   class ListUEdgeSet 
@@ -568 +568 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref concept::Graph
+  /// this class. Its interface must conform to the \ref concepts::Graph
   /// "Graph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref concept::Graph "Graph" concept.
+  /// \ref concepts::Graph "Graph" concept.
   template <typename _Graph>
   class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<_Graph> > {
@@ -672 +672 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref concept::Graph
+  /// this class. Its interface must conform to the \ref concepts::Graph
   /// "Graph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref concept::UGraph "UGraph" concept.
+  /// \ref concepts::UGraph "UGraph" concept.
   template <typename _Graph>
   class SmartUEdgeSet 

lemon/floyd_warshall.h

@@ -95 +95 @@
     ///
     /// The type of the map that stores the edge lengths.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _LengthMap LengthMap;
 
@@ -130 +130 @@
     ///
     /// The type of the map that stores the dists of the nodes.
-    /// It must meet the \ref concept::WriteMatrixMap "WriteMatrixMap" concept.
+    /// It must meet the \ref concepts::WriteMatrixMap "WriteMatrixMap" concept.
     ///
     typedef DynamicMatrixMap<Graph, typename Graph::Node, Value> DistMap;
@@ -150 +150 @@
   /// This class provides an efficient implementation of \c Floyd-Warshall 
   /// algorithm. The edge lengths are passed to the algorithm using a
-  /// \ref concept::ReadMap "ReadMap", so it is easy to change it to any 
+  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
   /// kind of length.
   ///
@@ -163 +163 @@
   ///
   /// The type of the length is determined by the
-  /// \ref concept::ReadMap::Value "Value" of the length map.
+  /// \ref concepts::ReadMap::Value "Value" of the length map.
   ///
   /// \param _Graph The graph type the algorithm runs on. The default value
@@ -172 +172 @@
   /// relatively time consuming process to compute the edge length if
   /// it is necessary. The default map type is \ref
-  /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
+  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   /// of _LengthMap is not used directly by FloydWarshall, it is only passed 
   /// to \ref FloydWarshallDefaultTraits.  \param _Traits Traits class to set

lemon/fredman_tarjan.h

@@ -37 +37 @@
 #include <lemon/graph_utils.h>
 
-#include <lemon/concept/ugraph.h>
+#include <lemon/concepts/ugraph.h>
 
 namespace lemon {
@@ -53 +53 @@
 
     ///The type of the map that stores the edge costs.
-    ///It must meet the \ref concept::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef CM CostMap;
     //The type of the cost of the edges.
@@ -62 +62 @@
     ///The type of the map that stores whether an edge is in the
     ///spanning tree or not.
-    ///It must meet the \ref concept::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     ///By default it is a BoolEdgeMap.
     typedef typename UGraph::template UEdgeMap<bool> TreeMap;
@@ -89 +89 @@
   ///
   ///The edge costs are passed to the algorithm using a \ref
-  ///concept::ReadMap "ReadMap", so it is easy to change it to any
+  ///concepts::ReadMap "ReadMap", so it is easy to change it to any
   ///kind of cost.
   ///
   ///The type of the cost is determined by the \ref
-  ///concept::ReadMap::Value "Value" of the cost map.
+  ///concepts::ReadMap::Value "Value" of the cost map.
   ///
   ///\param GR The graph type the algorithm runs on. The default value
@@ -104 +104 @@
   ///relatively time consuming process to compute the edge cost if it
   ///is necessary. The default map type is \ref
-  ///concept::UGraph::UEdgeMap "UGraph::UEdgeMap<int>". The value of
+  ///concepts::UGraph::UEdgeMap "UGraph::UEdgeMap<int>". The value of
   ///CM is not used directly by FredmanTarjan, it is only passed to
   ///\ref FredmanTarjanDefaultTraits.
@@ -366 +366 @@
       _tree(0), local_tree(false)
     {
-      checkConcept<concept::UGraph, UGraph>();
+      checkConcept<concepts::UGraph, UGraph>();
     }
     

lemon/full_graph.h

@@ -168 +168 @@
   /// edges or nodes.
   /// Thus it conforms to
-  /// the \ref concept::Graph "Graph" concept and
+  /// the \ref concepts::Graph "Graph" concept and
   ///it also has an
   ///important extra feature that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
-  /// \sa concept::Graph.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
+  /// \sa concepts::Graph.
   ///
   /// \sa FullUGraph
@@ -385 +385 @@
   ///It also has an
   ///important extra feature that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
   ///
   /// \sa FullGraph

lemon/graph_adaptor.h

@@ -2493 +2493 @@
   ///
   /// This graph adaptor is fully conform to the 
-  /// \ref concept::Graph "Graph" concept and
+  /// \ref concepts::Graph "Graph" concept and
   /// contains some additional member functions and types. The 
   /// documentation of some member functions may be found just in the

lemon/grid_ugraph.h

@@ -293 +293 @@
   ///\endcode
   ///
-  /// The graph type is fully conform to the \ref concept::UGraph
+  /// The graph type is fully conform to the \ref concepts::UGraph
   /// "Undirected Graph" concept,  and it also has an
   ///important extra feature that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
   ///
   ///

lemon/hypercube_graph.h

@@ -190 +190 @@
   /// is 26. 
   ///
-  /// The graph type is fully conform to the \ref concept::Graph
-  /// concept but it does not conform to the \ref concept::UGraph.
+  /// The graph type is fully conform to the \ref concepts::Graph
+  /// concept but it does not conform to the \ref concepts::UGraph.
   ///
   /// \author Balazs Dezso

lemon/johnson.h

@@ -97 +97 @@
     ///
     /// The type of the map that stores the edge lengths.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _LengthMap LengthMap;
 
@@ -163 +163 @@
     ///
     /// The type of the matrix map that stores the dists of the nodes.
-    /// It must meet the \ref concept::WriteMatrixMap "WriteMatrixMap" concept.
+    /// It must meet the \ref concepts::WriteMatrixMap "WriteMatrixMap" concept.
     ///
     typedef DynamicMatrixMap<Graph, typename Graph::Node, Value> DistMap;
@@ -183 +183 @@
   /// This class provides an efficient implementation of \c %Johnson 
   /// algorithm. The edge lengths are passed to the algorithm using a
-  /// \ref concept::ReadMap "ReadMap", so it is easy to change it to any 
+  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
   /// kind of length.
   ///
@@ -198 +198 @@
   ///
   /// The type of the length is determined by the
-  /// \ref concept::ReadMap::Value "Value" of the length map.
+  /// \ref concepts::ReadMap::Value "Value" of the length map.
   ///
   /// \param _Graph The graph type the algorithm runs on. The default value
@@ -207 +207 @@
   /// relatively time consuming process to compute the edge length if
   /// it is necessary. The default map type is \ref
-  /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
+  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   /// of _LengthMap is not used directly by Johnson, it is only passed 
   /// to \ref JohnsonDefaultTraits.  \param _Traits Traits class to set

lemon/kruskal.h

@@ -45 +45 @@
   ///
   /// \param g The graph the algorithm runs on.
-  /// It can be either \ref concept::Graph "directed" or 
-  /// \ref concept::UGraph "undirected".
+  /// It can be either \ref concepts::Graph "directed" or 
+  /// \ref concepts::UGraph "undirected".
   /// If the graph is directed, the algorithm consider it to be 
   /// undirected by disregarding the direction of the edges.
@@ -84 +84 @@
   ///
   /// \warning If kruskal runs on an
-  /// \ref lemon::concept::UGraph "undirected graph", be sure that the
+  /// \ref lemon::concepts::UGraph "undirected graph", be sure that the
   /// map storing the tree is also undirected
   /// (e.g. ListUGraph::UEdgeMap<bool>, otherwise the values of the

lemon/lemon_reader.h

@@ -42 +42 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 
 namespace lemon {
@@ -832 +832 @@
     NodeSetReader& _readMap(std::string name, MapParameter map, 
                             const Reader& reader = Reader()) {
-      checkConcept<concept::WriteMap<Node, typename Map::Value>, Map>();
+      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
       if (readers.find(name) != readers.end()) {
@@ -1062 +1062 @@
     EdgeSetReader& _readMap(std::string name, MapParameter map, 
                             const Reader& reader = Reader()) {
-      checkConcept<concept::WriteMap<Edge, typename Map::Value>, Map>();
+      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
       if (readers.find(name) != readers.end()) {
@@ -1306 +1306 @@
     UEdgeSetReader& _readMap(std::string name, MapParameter map,
                                  const Reader& reader = Reader()) {
-      checkConcept<concept::WriteMap<UEdge, typename Map::Value>, Map>();
+      checkConcept<concepts::WriteMap<UEdge, typename Map::Value>, Map>();
       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
       if (readers.find(name) != readers.end()) {
@@ -1377 +1377 @@
                                     const Reader& reader = Reader()) { 
       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
-      checkConcept<concept::WriteMap<Edge, typename Map::Value>, Map>();
+      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
       readMap("+" + name, 
               _reader_bits::forwardComposeMap(graph, map), reader);

lemon/lemon_writer.h

@@ -41 +41 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 
 
@@ -484 +484 @@
     NodeSetWriter& writeNodeMap(std::string name, const Map& map, 
                             const Writer& writer = Writer()) {
-      checkConcept<concept::ReadMap<Node, typename Map::Value>, Map>();
+      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
       writers.push_back(
@@ -673 +673 @@
     EdgeSetWriter& writeEdgeMap(std::string name, const Map& map, 
                             const Writer& writer = Writer()) {
-      checkConcept<concept::ReadMap<Edge, typename Map::Value>, Map>();
+      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
       writers.push_back(
@@ -879 +879 @@
     UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map, 
                                           const Writer& writer = Writer()) {
-      checkConcept<concept::ReadMap<UEdge, typename Map::Value>, Map>();
+      checkConcept<concepts::ReadMap<UEdge, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
       writers.push_back(
@@ -902 +902 @@
     UEdgeSetWriter& writeEdgeMap(std::string name, const Map& map, 
                                      const Writer& writer = Writer()) {
-      checkConcept<concept::ReadMap<Edge, typename Map::Value>, Map>();
+      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
       writeUEdge("+" + name, 

lemon/list_graph.h

@@ -319 +319 @@
   ///This is a simple and fast graph implementation.
   ///
-  ///It conforms to the \ref concept::Graph "Graph concept" and it
+  ///It conforms to the \ref concepts::Graph "Graph concept" and it
   ///also provides several additional useful extra functionalities.
   ///The most of the member functions and nested classes are
@@ -325 +325 @@
   ///
   ///An important extra feature of this graph implementation is that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
   ///
-  ///\sa concept::Graph.
+  ///\sa concepts::Graph.
 
   class ListGraph : public ExtendedListGraphBase {
@@ -749 +749 @@
   ///
   ///An important extra feature of this graph implementation is that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
   ///
   ///It conforms to the
-  ///\ref concept::UGraph "UGraph concept".
+  ///\ref concepts::UGraph "UGraph concept".
   ///
-  ///\sa concept::UGraph.
+  ///\sa concepts::UGraph.
   ///
   class ListUGraph : public ExtendedListUGraphBase {
@@ -1498 +1498 @@
   ///
   /// This is a bipartite undirected graph implementation.
-  /// It is conforms to the \ref concept::BpUGraph "BpUGraph concept".
+  /// It is conforms to the \ref concepts::BpUGraph "BpUGraph concept".
   ///
   ///An important extra feature of this graph implementation is that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
   ///
-  /// \sa concept::BpUGraph.
+  /// \sa concepts::BpUGraph.
   ///
   class ListBpUGraph : public ExtendedListBpUGraphBase {

lemon/lp_base.h

@@ -666 +666 @@
     ///std::map<AnyType,LpSolverBase::Col>
     ///\endcode
-    ///- an iterable lemon \ref concept::WriteMap "write map" like 
+    ///- an iterable lemon \ref concepts::WriteMap "write map" like 
     ///\code
     ///ListGraph::NodeMap<LpSolverBase::Col>
@@ -766 +766 @@
     ///std::map<AnyType,LpSolverBase::Row>
     ///\endcode
-    ///- an iterable lemon \ref concept::WriteMap "write map" like 
+    ///- an iterable lemon \ref concepts::WriteMap "write map" like 
     ///\code
     ///ListGraph::NodeMap<LpSolverBase::Row>

lemon/maps.h

@@ -30 +30 @@
 ///\brief Miscellaneous property maps
 ///
-///\todo This file has the same name as the concept file in concept/,
+///\todo This file has the same name as the concept file in concepts/,
 /// and this is not easily detectable in docs...
 
@@ -253 +253 @@
   ///Convert the \c Value of a map to another type.
 
-  ///This \ref concept::ReadMap "read only map"
+  ///This \ref concepts::ReadMap "read only map"
   ///converts the \c Value of a maps to type \c T.
   ///Its \c Key is inherited from \c M.
@@ -290 +290 @@
   ///Simple wrapping of the map
 
-  ///This \ref concept::ReadMap "read only map" returns the simple
+  ///This \ref concepts::ReadMap "read only map" returns the simple
   ///wrapping of the given map. Sometimes the reference maps cannot be
   ///combined with simple read maps. This map adaptor wraps the given
@@ -310 +310 @@
   ///Simple writeable wrapping of the map
 
-  ///This \ref concept::ReadMap "read only map" returns the simple
+  ///This \ref concepts::ReadMap "read only map" returns the simple
   ///wrapping of the given map. Sometimes the reference maps cannot be
   ///combined with simple read-write maps. This map adaptor wraps the
@@ -331 +331 @@
   ///Sum of two maps
 
-  ///This \ref concept::ReadMap "read only map" returns the sum of the two
+  ///This \ref concepts::ReadMap "read only map" returns the sum of the two
   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of M2 must be convertible to those of \c M1.
@@ -364 +364 @@
   ///Shift a map with a constant.
 
-  ///This \ref concept::ReadMap "read only map" returns the sum of the
+  ///This \ref concepts::ReadMap "read only map" returns the sum of the
   ///given map and a constant value.
   ///Its \c Key and \c Value is inherited from \c M.
@@ -397 +397 @@
   ///Shift a map with a constant.
 
-  ///This \ref concept::ReadWriteMap "read-write map" returns the sum of the
+  ///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
   ///given map and a constant value. It makes also possible to write the map.
   ///Its \c Key and \c Value is inherited from \c M.
@@ -446 +446 @@
   ///Difference of two maps
 
-  ///This \ref concept::ReadMap "read only map" returns the difference
+  ///This \ref concepts::ReadMap "read only map" returns the difference
   ///of the values of the two
   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
@@ -477 +477 @@
   ///Product of two maps
 
-  ///This \ref concept::ReadMap "read only map" returns the product of the
+  ///This \ref concepts::ReadMap "read only map" returns the product of the
   ///values of the two
   ///given
@@ -508 +508 @@
   ///Scales a maps with a constant.
 
-  ///This \ref concept::ReadMap "read only map" returns the value of the
+  ///This \ref concepts::ReadMap "read only map" returns the value of the
   ///given map multiplied from the left side with a constant value.
   ///Its \c Key and \c Value is inherited from \c M.
@@ -541 +541 @@
   ///Scales a maps with a constant.
 
-  ///This \ref concept::ReadWriteMap "read-write map" returns the value of the
+  ///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
   ///given map multiplied from the left side with a constant value. It can
   ///be used as write map also if the given multiplier is not zero.
@@ -581 +581 @@
   ///Quotient of two maps
 
-  ///This \ref concept::ReadMap "read only map" returns the quotient of the
+  ///This \ref concepts::ReadMap "read only map" returns the quotient of the
   ///values of the two
   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
@@ -611 +611 @@
   ///Composition of two maps
 
-  ///This \ref concept::ReadMap "read only map" returns the composition of
+  ///This \ref concepts::ReadMap "read only map" returns the composition of
   ///two
   ///given maps. That is to say, if \c m1 is of type \c M1 and \c m2 is
@@ -656 +656 @@
   ///
   ///
-  ///This \ref concept::ReadMap "read only map" takes two maps and a
+  ///This \ref concepts::ReadMap "read only map" takes two maps and a
   ///binary functor and returns the composition of
   ///the two
@@ -728 +728 @@
   ///Negative value of a map
 
-  ///This \ref concept::ReadMap "read only map" returns the negative
+  ///This \ref concepts::ReadMap "read only map" returns the negative
   ///value of the
   ///value returned by the
@@ -749 +749 @@
   ///Negative value of a map
 
-  ///This \ref concept::ReadWriteMap "read-write map" returns the negative
+  ///This \ref concepts::ReadWriteMap "read-write map" returns the negative
   ///value of the value returned by the
   ///given map. Its \c Key and \c Value will be inherited from \c M.
@@ -784 +784 @@
   ///Absolute value of a map
 
-  ///This \ref concept::ReadMap "read only map" returns the absolute value
+  ///This \ref concepts::ReadMap "read only map" returns the absolute value
   ///of the
   ///value returned by the
@@ -833 +833 @@
   ///Converts an STL style functor to a map
 
-  ///This \ref concept::ReadMap "read only map" returns the value
+  ///This \ref concepts::ReadMap "read only map" returns the value
   ///of a
   ///given map.
@@ -891 +891 @@
   ///
   ///For the sake of convenience it also works as
-  ///a ususal \ref concept::ReadMap "readable map",
+  ///a ususal \ref concepts::ReadMap "readable map",
   ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
 
@@ -926 +926 @@
   ///Applies all map setting operations to two maps
 
-  ///This map has two \ref concept::ReadMap "readable map"
+  ///This map has two \ref concepts::ReadMap "readable map"
   ///parameters and each read request will be passed just to the
   ///first map. This class is the just readable map type of the ForkWriteMap.
@@ -950 +950 @@
   ///Applies all map setting operations to two maps
 
-  ///This map has two \ref concept::WriteMap "writable map"
+  ///This map has two \ref concepts::WriteMap "writable map"
   ///parameters and each write request will be passed to both of them.
-  ///If \c M1 is also \ref concept::ReadMap "readable",
+  ///If \c M1 is also \ref concepts::ReadMap "readable",
   ///then the read operations will return the
   ///corresponding values of \c M1.
@@ -997 +997 @@
   ///Logical 'not' of a map
   
-  ///This bool \ref concept::ReadMap "read only map" returns the 
+  ///This bool \ref concepts::ReadMap "read only map" returns the 
   ///logical negation of
   ///value returned by the
@@ -1018 +1018 @@
   ///Logical 'not' of a map with writing possibility
   
-  ///This bool \ref concept::ReadWriteMap "read-write map" returns the 
+  ///This bool \ref concepts::ReadWriteMap "read-write map" returns the 
   ///logical negation of value returned by the given map. When it is set,
   ///the opposite value is set to the original map.

lemon/matrix_maps.h

@@ -26 +26 @@
 #include <lemon/maps.h>
 
-#include <lemon/concept/matrix_maps.h>
+#include <lemon/concepts/matrix_maps.h>
 
 /// \file
@@ -32 +32 @@
 /// \brief Maps indexed with pairs of items.
 ///
-/// \todo This file has the same name as the concept file in concept/,
+/// \todo This file has the same name as the concept file in concepts/,
 ///  and this is not easily detectable in docs...
 namespace lemon {
@@ -296 +296 @@
     template <typename CMap>
     DynamicMatrixMap& operator=(const CMap& _cmap){
-      checkConcept<concept::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
+      checkConcept<concepts::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
       typename Parent::Notifier* notifier = Parent::getNotifier();
       Key first, second;
@@ -433 +433 @@
     template <typename CMap>
     DynamicSymMatrixMap& operator=(const CMap& _cmap){
-      checkConcept<concept::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
+      checkConcept<concepts::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
       typename Parent::Notifier* notifier = Parent::getNotifier();
       Key first, second;
@@ -520 +520 @@
   ///needed.
   ///
-  ///This map meet with the concept::ReferenceMatrixMap<typename K1,
+  ///This map meet with the concepts::ReferenceMatrixMap<typename K1,
   ///typename K2, typename V, typename R, typename CR> called as
   ///"ReferenceMatrixMap".
@@ -861 +861 @@
     template <typename CMap>
     DynamicAsymMatrixMap& operator=(const CMap& _cdmap){
-      checkConcept<concept::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
+      checkConcept<concepts::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
       const typename FirstKeyProxy::Notifier* notifierFirstKey = 
         _first_key_proxy.getNotifier();

lemon/min_cost_arborescence.h

@@ -46 +46 @@
     ///
     /// The type of the map that stores the edge costs.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _CostMap CostMap;
 
@@ -58 +58 @@
     ///
     /// The type of the map that stores which edges are in the arborescence.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     /// Initially it will be set to false on each edge. After it
     /// will set all arborescence edges once.
@@ -111 +111 @@
   /// relatively time consuming process to compute the edge cost if
   /// it is necessary. The default map type is \ref
-  /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
+  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   /// of _CostMap is not used directly by MinCostArborescence, 
   /// it is only passed to \ref MinCostArborescenceDefaultTraits.  

lemon/min_cut.h

@@ -68 +68 @@
     ///
     /// The type of the map that stores the edge capacities.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _CapacityMap CapacityMap;
 
@@ -114 +114 @@
     ///
     /// The type of the map that stores whether a nodes is processed.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     /// By default it is a NullMap.
     typedef NullMap<typename Graph::Node, bool> ProcessedMap;
@@ -135 +135 @@
     /// 
     /// The type of the map that stores the cardinalities of the nodes.
-    /// It must meet the \ref concept::WriteMap "WriteMap" concept.
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Graph::template NodeMap<Value> CardinalityMap;
 
@@ -163 +163 @@
   ///
   /// The edge capacities are passed to the algorithm using a
-  /// \ref concept::ReadMap "ReadMap", so it is easy to change it to any 
+  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
   /// kind of capacity.
   ///
   /// The type of the capacity is determined by the \ref 
-  /// concept::ReadMap::Value "Value" of the capacity map.
+  /// concepts::ReadMap::Value "Value" of the capacity map.
   ///
   /// It is also possible to change the underlying priority heap.
@@ -180 +180 @@
   /// relatively time consuming process to compute the edge capacity if
   /// it is necessary. The default map type is \ref
-  /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
+  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
   /// of CapacityMap is not used directly by search algorithm, it is only 
   /// passed to \ref MaxCardinalitySearchDefaultTraits.  
@@ -715 +715 @@
     ///
     /// The type of the map that stores the edge capacities.
-    /// It must meet the \ref concept::ReadMap "ReadMap" concept.
+    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef _CapacityMap CapacityMap;
 

lemon/prim.h

@@ -31 +31 @@
 #include <lemon/bits/traits.h>
 
-#include <lemon/concept/ugraph.h>
+#include <lemon/concepts/ugraph.h>
 
 namespace lemon {
@@ -47 +47 @@
 
     ///The type of the map that stores the edge costs.
-    ///It must meet the \ref concept::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef CM CostMap;
     //The type of the cost of the edges.
@@ -83 +83 @@
     ///The type of the map that stores the last
     ///edges of the minimum spanning tree.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///
     typedef typename UGraph::template NodeMap<typename GR::UEdge> PredMap;
@@ -114 +114 @@
  
     ///The type of the map that stores whether a nodes is processed.
-    ///It must meet the \ref concept::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NodeMap<bool>.
     typedef NullMap<typename UGraph::Node,bool> ProcessedMap;
@@ -141 +141 @@
   ///
   ///The edge costs are passed to the algorithm using a
-  ///\ref concept::ReadMap "ReadMap",
+  ///\ref concepts::ReadMap "ReadMap",
   ///so it is easy to change it to any kind of cost.
   ///
   ///The type of the cost is determined by the
-  ///\ref concept::ReadMap::Value "Value" of the cost map.
+  ///\ref concepts::ReadMap::Value "Value" of the cost map.
   ///
   ///It is also possible to change the underlying priority heap.
@@ -157 +157 @@
   ///relatively time consuming process to compute the edge cost if
   ///it is necessary. The default map type is \ref
-  ///concept::UGraph::UEdgeMap "UGraph::UEdgeMap<int>".  The value
+  ///concepts::UGraph::UEdgeMap "UGraph::UEdgeMap<int>".  The value
   ///of CM is not used directly by Prim, it is only passed to \ref
   ///PrimDefaultTraits.
@@ -413 +413 @@
       _heap(NULL), local_heap(false)
     {
-      checkConcept<concept::UGraph, UGraph>();
+      checkConcept<concepts::UGraph, UGraph>();
     }
     

lemon/smart_graph.h

@@ -195 +195 @@
   ///node and edge deletions</b>.
   ///It conforms to 
-  ///the \ref concept::Graph "Graph concept" with an
+  ///the \ref concepts::Graph "Graph concept" with an
   ///important extra feature that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
-  ///
-  ///\sa concept::Graph.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
+  ///
+  ///\sa concepts::Graph.
   ///
   ///\author Alpar Juttner
@@ -381 +381 @@
   /// node and edge deletions</b>.
   /// Except from this it conforms to 
-  /// the \ref concept::UGraph "UGraph concept".
+  /// the \ref concepts::UGraph "UGraph concept".
   ///
   ///It also has an
   ///important extra feature that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
-  ///
-  /// \sa concept::UGraph.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
+  ///
+  /// \sa concepts::UGraph.
   ///
   /// \todo Snapshot hasn't been implemented yet.
@@ -763 +763 @@
   /// that <b> it does not support node and edge deletions</b>.
   /// Except from this it conforms to 
-  /// the \ref concept::BpUGraph "BpUGraph concept".
+  /// the \ref concepts::BpUGraph "BpUGraph concept".
   ///
   ///It also has an
   ///important extra feature that
-  ///its maps are real \ref concept::ReferenceMap "reference map"s.
-  ///
-  /// \sa concept::BpUGraph.
+  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
+  ///
+  /// \sa concepts::BpUGraph.
   ///
   class SmartBpUGraph : public ExtendedSmartBpUGraphBase {

lemon/topology.h

@@ -26 +26 @@
 #include <lemon/maps.h>
 
-#include <lemon/concept/graph.h>
-#include <lemon/concept/ugraph.h>
+#include <lemon/concepts/graph.h>
+#include <lemon/concepts/ugraph.h>
 #include <lemon/concept_check.h>
 
@@ -54 +54 @@
   template <typename UGraph>
   bool connected(const UGraph& graph) {
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::NodeIt NodeIt;
     if (NodeIt(graph) == INVALID) return true;
@@ -79 +79 @@
   template <typename UGraph>
   int countConnectedComponents(const UGraph &graph) {
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::Node Node;
     typedef typename UGraph::Edge Edge;
@@ -127 +127 @@
   template <class UGraph, class NodeMap>
   int connectedComponents(const UGraph &graph, NodeMap &compMap) {
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::Node Node;
     typedef typename UGraph::Edge Edge;
-    checkConcept<concept::WriteMap<Node, int>, NodeMap>();
+    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
 
     typedef NullMap<Node, Edge> PredMap;
@@ -245 +245 @@
   template <typename Graph>
   bool stronglyConnected(const Graph& graph) {
-    checkConcept<concept::Graph, Graph>();
+    checkConcept<concepts::Graph, Graph>();
 
     typedef typename Graph::Node Node;
@@ -303 +303 @@
   template <typename Graph>
   int countStronglyConnectedComponents(const Graph& graph) {
-    checkConcept<concept::Graph, Graph>();
+    checkConcept<concepts::Graph, Graph>();
 
     using namespace _topology_bits;
@@ -372 +372 @@
   template <typename Graph, typename NodeMap>
   int stronglyConnectedComponents(const Graph& graph, NodeMap& compMap) {
-    checkConcept<concept::Graph, Graph>();
+    checkConcept<concepts::Graph, Graph>();
     typedef typename Graph::Node Node;
     typedef typename Graph::NodeIt NodeIt;
-    checkConcept<concept::WriteMap<Node, int>, NodeMap>();
+    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
 
     using namespace _topology_bits;
@@ -435 +435 @@
   template <typename Graph, typename EdgeMap>
   int stronglyConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) {
-    checkConcept<concept::Graph, Graph>();
+    checkConcept<concepts::Graph, Graph>();
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
     typedef typename Graph::NodeIt NodeIt;
-    checkConcept<concept::WriteMap<Edge, bool>, EdgeMap>();
+    checkConcept<concepts::WriteMap<Edge, bool>, EdgeMap>();
 
     using namespace _topology_bits;
@@ -731 +731 @@
   template <typename UGraph>
   int countBiNodeConnectedComponents(const UGraph& graph) {
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::NodeIt NodeIt;
 
@@ -775 +775 @@
   int biNodeConnectedComponents(const UGraph& graph, 
                                 UEdgeMap& compMap) {
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::NodeIt NodeIt;
     typedef typename UGraph::UEdge UEdge;
-    checkConcept<concept::WriteMap<UEdge, int>, UEdgeMap>();
+    checkConcept<concepts::WriteMap<UEdge, int>, UEdgeMap>();
 
     using namespace _topology_bits;
@@ -815 +815 @@
   template <typename UGraph, typename NodeMap>
   int biNodeConnectedCutNodes(const UGraph& graph, NodeMap& cutMap) {
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::Node Node;
     typedef typename UGraph::NodeIt NodeIt;
-    checkConcept<concept::WriteMap<Node, bool>, NodeMap>();
+    checkConcept<concepts::WriteMap<Node, bool>, NodeMap>();
 
     using namespace _topology_bits;
@@ -1058 +1058 @@
   template <typename UGraph>
   int countBiEdgeConnectedComponents(const UGraph& graph) { 
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::NodeIt NodeIt;
 
@@ -1101 +1101 @@
   template <typename UGraph, typename NodeMap>
   int biEdgeConnectedComponents(const UGraph& graph, NodeMap& compMap) { 
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::NodeIt NodeIt;
     typedef typename UGraph::Node Node;
-    checkConcept<concept::WriteMap<Node, int>, NodeMap>();
+    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
 
     using namespace _topology_bits;
@@ -1142 +1142 @@
   template <typename UGraph, typename UEdgeMap>
   int biEdgeConnectedCutEdges(const UGraph& graph, UEdgeMap& cutMap) { 
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::NodeIt NodeIt;
     typedef typename UGraph::UEdge UEdge;
-    checkConcept<concept::WriteMap<UEdge, bool>, UEdgeMap>();
+    checkConcept<concepts::WriteMap<UEdge, bool>, UEdgeMap>();
 
     using namespace _topology_bits;
@@ -1206 +1206 @@
     using namespace _topology_bits;
 
-    checkConcept<concept::Graph, Graph>();
-    checkConcept<concept::WriteMap<typename Graph::Node, int>, NodeMap>();
+    checkConcept<concepts::Graph, Graph>();
+    checkConcept<concepts::WriteMap<typename Graph::Node, int>, NodeMap>();
 
     typedef typename Graph::Node Node;
@@ -1248 +1248 @@
     using namespace _topology_bits;
 
-    checkConcept<concept::Graph, Graph>();
-    checkConcept<concept::ReadWriteMap<typename Graph::Node, int>, NodeMap>();
+    checkConcept<concepts::Graph, Graph>();
+    checkConcept<concepts::ReadWriteMap<typename Graph::Node, int>, NodeMap>();
 
     typedef typename Graph::Node Node;
@@ -1291 +1291 @@
   bool dag(const Graph& graph) {
 
-    checkConcept<concept::Graph, Graph>();
+    checkConcept<concepts::Graph, Graph>();
 
     typedef typename Graph::Node Node;
@@ -1332 +1332 @@
   template <typename UGraph>
   bool acyclic(const UGraph& graph) {
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::Node Node;
     typedef typename UGraph::NodeIt NodeIt;
@@ -1365 +1365 @@
   template <typename UGraph>
   bool tree(const UGraph& graph) {
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     typedef typename UGraph::Node Node;
     typedef typename UGraph::NodeIt NodeIt;
@@ -1403 +1403 @@
   template<typename UGraph>
   inline bool bipartite(const UGraph &graph){
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     
     typedef typename UGraph::NodeIt NodeIt;
@@ -1440 +1440 @@
   template<typename UGraph, typename NodeMap>
   inline bool bipartitePartitions(const UGraph &graph, NodeMap &partMap){
-    checkConcept<concept::UGraph, UGraph>();
+    checkConcept<concepts::UGraph, UGraph>();
     
     typedef typename UGraph::Node Node;

lemon/vmap.h

@@ -60 +60 @@
   };
   
-  ///Makes a virtual map from a \ref concept::ReadMap "ReadMap"
+  ///Makes a virtual map from a \ref concepts::ReadMap "ReadMap"
   template<class M, class K=typename M::Key,class V=typename M::Value>
   class VReadMap : public VMapBase<K,V> 
@@ -75 +75 @@
   vReadMap(const M& m) {return VReadMap<M,K,V>(m);}
 
-  ///Makes a virtual map from a \ref concept::WriteMap "WriteMap"
+  ///Makes a virtual map from a \ref concepts::WriteMap "WriteMap"
   template<class M, class K=typename M::Key,class V=typename M::Value>
   class VWriteMap :public VMapBase<K,V> 
@@ -90 +90 @@
   vWriteMap(const M& m) {return VReadMap<M,K,V>(m);}
 
-  ///Makes a virtual map from a \ref concept::ReadWriteMap "ReadWriteMap"
+  ///Makes a virtual map from a \ref concepts::ReadWriteMap "ReadWriteMap"
   template<class M, class K=typename M::Key,class V=typename M::Value>
   class VReadWriteMap :public VMapBase<K,V>

test/bfs_test.cc

@@ -21 +21 @@
 #include <lemon/bfs.h>
 #include <lemon/path.h>
-#include<lemon/concept/graph.h>
+#include<lemon/concepts/graph.h>
 
 using namespace lemon;
@@ -30 +30 @@
 void check_Bfs_Compile() 
 {
-  typedef concept::Graph Graph;
+  typedef concepts::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -67 +67 @@
 {
   typedef int VType;
-  typedef concept::Graph Graph;
+  typedef concepts::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -73 +73 @@
   typedef Graph::EdgeIt EdgeIt;
   typedef Graph::NodeIt NodeIt;
-  typedef concept::ReadMap<Edge,VType> LengthMap;
+  typedef concepts::ReadMap<Edge,VType> LengthMap;
    
   Graph g;
@@ -79 +79 @@
   bfs(g).source(Node()).run();
   bfs(g)
-    .predMap(concept::WriteMap<Node,Edge>())
-    .distMap(concept::WriteMap<Node,VType>())
-    .reachedMap(concept::ReadWriteMap<Node,bool>())
-    .processedMap(concept::WriteMap<Node,bool>())
+    .predMap(concepts::WriteMap<Node,Edge>())
+    .distMap(concepts::WriteMap<Node,VType>())
+    .reachedMap(concepts::ReadWriteMap<Node,bool>())
+    .processedMap(concepts::WriteMap<Node,bool>())
     .run(Node());
   

test/bpugraph_test.cc

@@ -17 +17 @@
  */
 
-#include <lemon/concept/bpugraph.h>
+#include <lemon/concepts/bpugraph.h>
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
@@ -29 +29 @@
 
 using namespace lemon;
-using namespace lemon::concept;
+using namespace lemon::concepts;
 
 void check_concepts() {

test/dfs_test.cc

@@ -21 +21 @@
 #include <lemon/dfs.h>
 #include <lemon/path.h>
-#include <lemon/concept/graph.h>
+#include <lemon/concepts/graph.h>
 
 using namespace lemon;
@@ -30 +30 @@
 void check_Dfs_SmartGraph_Compile() 
 {
-  typedef concept::Graph Graph;
+  typedef concepts::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -68 +68 @@
 {
   typedef int VType;
-  typedef concept::Graph Graph;
+  typedef concepts::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -74 +74 @@
   typedef Graph::EdgeIt EdgeIt;
   typedef Graph::NodeIt NodeIt;
-  typedef concept::ReadMap<Edge,VType> LengthMap;
+  typedef concepts::ReadMap<Edge,VType> LengthMap;
    
   Graph g;
@@ -80 +80 @@
   dfs(g).source(Node()).run();
   dfs(g)
-    .predMap(concept::WriteMap<Node,Edge>())
-    .distMap(concept::WriteMap<Node,VType>())
-    .reachedMap(concept::ReadWriteMap<Node,bool>())
-    .processedMap(concept::WriteMap<Node,bool>())
+    .predMap(concepts::WriteMap<Node,Edge>())
+    .distMap(concepts::WriteMap<Node,VType>())
+    .reachedMap(concepts::ReadWriteMap<Node,bool>())
+    .processedMap(concepts::WriteMap<Node,bool>())
     .run(Node());
   

test/dijkstra_test.cc

@@ -22 +22 @@
 #include <lemon/path.h>
 #include <lemon/maps.h>
-#include <lemon/concept/graph.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/graph.h>
+#include <lemon/concepts/maps.h>
 using namespace lemon;
 
@@ -32 +32 @@
 {
   typedef int VType;
-  typedef concept::Graph Graph;
+  typedef concepts::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -38 +38 @@
   typedef Graph::EdgeIt EdgeIt;
   typedef Graph::NodeIt NodeIt;
-  typedef concept::ReadMap<Edge,VType> LengthMap;
+  typedef concepts::ReadMap<Edge,VType> LengthMap;
  
   typedef Dijkstra<Graph, LengthMap> DType;
@@ -71 +71 @@
 {
   typedef int VType;
-  typedef concept::Graph Graph;
+  typedef concepts::Graph Graph;
 
   typedef Graph::Edge Edge;
@@ -77 +77 @@
   typedef Graph::EdgeIt EdgeIt;
   typedef Graph::NodeIt NodeIt;
-  typedef concept::ReadMap<Edge,VType> LengthMap;
+  typedef concepts::ReadMap<Edge,VType> LengthMap;
    
   Graph g;
@@ -83 +83 @@
   dijkstra(g,LengthMap()).source(Node()).run();
   dijkstra(g,LengthMap())
-    .predMap(concept::WriteMap<Node,Edge>())
-    .distMap(concept::WriteMap<Node,VType>())
+    .predMap(concepts::WriteMap<Node,Edge>())
+    .distMap(concepts::WriteMap<Node,VType>())
     .run(Node());
   

test/edge_set_test.cc

@@ -4 +4 @@
 #include <vector>
 
-#include <lemon/concept/graph.h>
-#include <lemon/concept/ugraph.h>
+#include <lemon/concepts/graph.h>
+#include <lemon/concepts/ugraph.h>
 #include <lemon/smart_graph.h>
 
@@ -16 +16 @@
 
 using namespace lemon;
-using namespace lemon::concept;
+using namespace lemon::concepts;
 
 typedef SmartGraph RGraph;

test/graph_adaptor_test.cc

@@ -21 +21 @@
 
 #include<lemon/smart_graph.h>
-#include<lemon/concept/graph.h>
-#include<lemon/concept/ugraph.h>
-#include<lemon/concept/bpugraph.h>
+#include<lemon/concepts/graph.h>
+#include<lemon/concepts/ugraph.h>
+#include<lemon/concepts/bpugraph.h>
 
 #include<lemon/list_graph.h>
@@ -42 +42 @@
 
 using namespace lemon;
-using namespace lemon::concept;
+using namespace lemon::concepts;
 
 

test/graph_factory_test.cc

@@ -19 +19 @@
 #include<iostream>
 #include<lemon/smart_graph.h>
-#include<lemon/concept/graph.h>
-#include<lemon/concept/maps.h>
+#include<lemon/concepts/graph.h>
+#include<lemon/concepts/maps.h>
 #include<lemon/list_graph_base.h>
 #include<lemon/full_graph.h>
@@ -71 +71 @@
 
 //Compile Graph
-template void lemon::concept::checkCompileGraph<concept::Graph>
-(concept::Graph &);
+template void lemon::concepts::checkCompileGraph<concepts::Graph>
+(concepts::Graph &);
 
 template
-void lemon::concept::checkCompileGraph<concept::Graph>
-(concept::Graph &);
+void lemon::concepts::checkCompileGraph<concepts::Graph>
+(concepts::Graph &);
 
 template
-void lemon::concept::checkCompileGraph<concept::Graph>
-(concept::Graph &);
+void lemon::concepts::checkCompileGraph<concepts::Graph>
+(concepts::Graph &);
 
 //Compile SmartGraph
 template
-void lemon::concept::checkCompileGraph<SmartGraph>(SmartGraph &);
+void lemon::concepts::checkCompileGraph<SmartGraph>(SmartGraph &);
 template
-void lemon::concept::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
+void lemon::concepts::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
 
 //Compile SymSmartGraph
@@ -94 +94 @@
 //Compile ListGraph
 template
-void lemon::concept::checkCompileGraph<ListGraph>(ListGraph &);
+void lemon::concepts::checkCompileGraph<ListGraph>(ListGraph &);
 template
-void lemon::concept::checkCompileGraph<ListGraph>(ListGraph &);
+void lemon::concepts::checkCompileGraph<ListGraph>(ListGraph &);
 template
-void lemon::concept::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
+void lemon::concepts::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
 
 
@@ -107 +107 @@
 
 //Compile FullGraph
-template void lemon::concept::checkCompileGraph<FullGraph>(FullGraph &);
+template void lemon::concepts::checkCompileGraph<FullGraph>(FullGraph &);
 template
-void lemon::concept::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
+void lemon::concepts::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
 
 
@@ -144 +144 @@
   // Some map tests.
   // FIXME: These shouldn't be here.
-  using namespace concept;
+  using namespace concepts;
   function_requires< ReadMapConcept< ReadMap<int,int> > >();
   function_requires< WriteMapConcept< WriteMap<int,int> > >();

test/graph_test.cc

@@ -20 +20 @@
 #include <vector>
 
-#include <lemon/concept/graph.h>
+#include <lemon/concepts/graph.h>
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
@@ -32 +32 @@
 
 using namespace lemon;
-using namespace lemon::concept;
+using namespace lemon::concepts;
 
 

test/heap_test.cc

@@ -23 +23 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/heap.h>
+#include <lemon/concepts/heap.h>
 
 #include <lemon/smart_graph.h>
@@ -41 +41 @@
 
 using namespace lemon;
-using namespace lemon::concept;
+using namespace lemon::concepts;
 
 

test/kruskal_test.cc

@@ -24 +24 @@
 #include <lemon/kruskal.h>
 #include <lemon/list_graph.h>
-#include <lemon/concept/maps.h>
-#include <lemon/concept/graph.h>
+#include <lemon/concepts/maps.h>
+#include <lemon/concepts/graph.h>
 
 
@@ -33 +33 @@
 void checkCompileKruskal()
 {
-  concept::WriteMap<concept::Graph::Edge,bool> w;
+  concepts::WriteMap<concepts::Graph::Edge,bool> w;
 
-  concept::Graph g;
+  concepts::Graph g;
   kruskal(g,
-          concept::ReadMap<concept::Graph::Edge,int>(),
+          concepts::ReadMap<concepts::Graph::Edge,int>(),
           w);
 }

test/maps_test.cc

@@ -21 +21 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/maps.h>
 #include <lemon/maps.h>
 
@@ -27 +27 @@
 
 using namespace lemon;
-using namespace lemon::concept;
+using namespace lemon::concepts;
 
 struct A {};

test/matrix_maps_test.cc

@@ -22 +22 @@
 #include <lemon/concept_check.h>
 
-#include <lemon/concept/matrix_maps.h>
-#include <lemon/concept/maps.h>
-#include <lemon/concept/graph.h>
+#include <lemon/concepts/matrix_maps.h>
+#include <lemon/concepts/maps.h>
+#include <lemon/concepts/graph.h>
 
 #include <lemon/matrix_maps.h>
@@ -36 +36 @@
 
 using namespace lemon;
-using namespace lemon::concept;
+using namespace lemon::concepts;
 
 int main() {

test/path_test.cc

@@ -20 +20 @@
 #include <iostream>
 
-#include <lemon/concept/path.h>
-#include <lemon/concept/graph.h>
+#include <lemon/concepts/path.h>
+#include <lemon/concepts/graph.h>
 
 #include <lemon/path.h>
@@ -32 +32 @@
 
 void check_concepts() {
-  checkConcept<concept::Path<concept::Graph>, 
-    concept::Path<concept::Graph> >();
-  checkConcept<concept::Path<concept::Graph>, 
-    Path<concept::Graph> >();
-  checkConcept<concept::Path<ListGraph>, Path<ListGraph> >();
+  checkConcept<concepts::Path<concepts::Graph>, 
+    concepts::Path<concepts::Graph> >();
+  checkConcept<concepts::Path<concepts::Graph>, 
+    Path<concepts::Graph> >();
+  checkConcept<concepts::Path<ListGraph>, Path<ListGraph> >();
 }
 

test/preflow_test.cc

@@ -24 +24 @@
 #include <lemon/dimacs.h>
 #include <lemon/preflow.h>
-#include <lemon/concept/graph.h>
-#include <lemon/concept/maps.h>
+#include <lemon/concepts/graph.h>
+#include <lemon/concepts/maps.h>
 
 using namespace lemon;
@@ -32 +32 @@
 {
   typedef int VType;
-  typedef concept::Graph Graph;
+  typedef concepts::Graph Graph;
 
   typedef Graph::Node Node;
   typedef Graph::Edge Edge;
-  typedef concept::ReadMap<Edge,VType> CapMap;
-  typedef concept::ReadWriteMap<Edge,VType> FlowMap;
-  typedef concept::ReadWriteMap<Node,bool> CutMap;
+  typedef concepts::ReadMap<Edge,VType> CapMap;
+  typedef concepts::ReadWriteMap<Edge,VType> FlowMap;
+  typedef concepts::ReadWriteMap<Node,bool> CutMap;
  
   typedef Preflow<Graph, int, CapMap, FlowMap> PType;

test/test_tools.h

@@ -27 +27 @@
 
 #include <lemon/concept_check.h>
-#include <lemon/concept/graph.h>
+#include <lemon/concepts/graph.h>
 
 #include <lemon/random.h>

test/ugraph_test.cc

@@ -18 +18 @@
 
 #include <lemon/bits/graph_extender.h>
-#include <lemon/concept/ugraph.h>
+#include <lemon/concepts/ugraph.h>
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
@@ -30 +30 @@
 
 using namespace lemon;
-using namespace lemon::concept;
+using namespace lemon::concepts;
 
 void check_concepts() {