COIN-OR::LEMON - Graph Library

Changeset 2260:4274224f8a7d in lemon-0.x


Ignore:
Timestamp:
10/24/06 19:19:16 (13 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:
8 added
8 deleted
55 edited

Legend:

Unmodified
Added
Removed
  • Makefile.am

    r2234 r2260  
    1414lemondir = $(pkgincludedir)
    1515bitsdir = $(lemondir)/bits
    16 conceptdir = $(lemondir)/concept
     16conceptdir = $(lemondir)/concepts
    1717pkgconfig_DATA =
    1818lib_LTLIBRARIES =
  • doc/graphs.dox

    r2116 r2260  
    1212as  incoming and outgoing edges of a given node.
    1313
    14 Each graph should meet the \ref lemon::concept::Graph "Graph" concept.
     14Each graph should meet the \ref lemon::concepts::Graph "Graph" concept.
    1515This concept does not make it possible to change the graph (i.e. it is
    1616not possible to add or delete edges or nodes). Most of the graph
     
    1919
    2020In case of graphs meeting the full feature
    21 \ref lemon::concept::ErasableGraph "ErasableGraph"
     21\ref lemon::concepts::ErasableGraph "ErasableGraph"
    2222concept
    2323you can also erase individual edges and nodes in arbitrary order.
     
    2525The implemented graph structures are the following.
    2626\li \ref lemon::ListGraph "ListGraph" is the most versatile graph class. It meets
    27 the \ref lemon::concept::ErasableGraph "ErasableGraph" concept
     27the \ref lemon::concepts::ErasableGraph "ErasableGraph" concept
    2828and it also has some convenient extra features.
    2929\li \ref lemon::SmartGraph "SmartGraph" is a more memory
    3030efficient version of \ref lemon::ListGraph "ListGraph". The
    3131price of this is that it only meets the
    32 \ref lemon::concept::ExtendableGraph "ExtendableGraph" concept,
     32\ref lemon::concepts::ExtendableGraph "ExtendableGraph" concept,
    3333so you cannot delete individual edges or nodes.
    3434\li \ref lemon::FullGraph "FullGraph"
    3535implements a complete graph. It is a
    36 \ref lemon::concept::Graph "Graph", so you cannot
     36\ref lemon::concepts::Graph "Graph", so you cannot
    3737change the number of nodes once it is constructed. It is extremely memory
    3838efficient: it uses constant amount of memory independently from the number of
  • doc/groups.dox

    r2233 r2260  
    7777Map adaptors are used to create "implicit" maps from other maps.
    7878
    79 Most of them are \ref lemon::concept::ReadMap "ReadMap"s. They can
     79Most of them are \ref lemon::concepts::ReadMap "ReadMap"s. They can
    8080make arithmetic operations between one or two maps (negation, scaling,
    8181addition, multiplication etc.) or e.g. convert a map to another one
     
    103103algorithm to store its result in any kind of path structure.
    104104
    105 \sa lemon::concept::Path
     105\sa lemon::concepts::Path
    106106
    107107*/
  • doc/maps.dox

    r1788 r2260  
    1414
    1515A map can be
    16 \e readable (\ref lemon::concept::ReadMap "ReadMap", for short),
    17 \e writable (\ref lemon::concept::WriteMap "WriteMap") or both
    18 (\ref lemon::concept::ReadWriteMap "ReadWriteMap").
     16\e readable (\ref lemon::concepts::ReadMap "ReadMap", for short),
     17\e writable (\ref lemon::concepts::WriteMap "WriteMap") or both
     18(\ref lemon::concepts::ReadWriteMap "ReadWriteMap").
    1919There also exists a special type of
    20 ReadWrite map called \ref lemon::concept::ReferenceMap "reference map".
     20ReadWrite map called \ref lemon::concepts::ReferenceMap "reference map".
    2121In addition that you can
    2222read and write the values of a key, a reference map
  • doc/namespaces.dox

    r2157 r2260  
    99  /// The namespace of LEMON concepts and concept checking classes
    1010  ///
    11   namespace concept {}
     11  namespace concepts {}
    1212}
  • lemon/Makefile.am

    r2229 r2260  
    122122concept_HEADERS += \
    123123        lemon/concept_check.h \
    124         lemon/concept/bpugraph.h \
    125         lemon/concept/graph.h \
    126         lemon/concept/graph_components.h \
    127         lemon/concept/heap.h \
    128         lemon/concept/maps.h \
    129         lemon/concept/matrix_maps.h \
    130         lemon/concept/path.h \
    131         lemon/concept/ugraph.h
     124        lemon/concepts/bpugraph.h \
     125        lemon/concepts/graph.h \
     126        lemon/concepts/graph_components.h \
     127        lemon/concepts/heap.h \
     128        lemon/concepts/maps.h \
     129        lemon/concepts/matrix_maps.h \
     130        lemon/concepts/path.h \
     131        lemon/concepts/ugraph.h
  • lemon/bellman_ford.h

    r2151 r2260  
    9393    ///
    9494    /// The type of the map that stores the edge lengths.
    95     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     95    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    9696    typedef _LengthMap LengthMap;
    9797
     
    111111    /// The type of the map that stores the last
    112112    /// edges of the shortest paths.
    113     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     113    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    114114    ///
    115115    typedef typename Graph::template NodeMap<typename _Graph::Edge> PredMap;
     
    126126    ///
    127127    /// The type of the map that stores the dists of the nodes.
    128     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     128    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    129129    ///
    130130    typedef typename Graph::template NodeMap<typename _LengthMap::Value>
     
    147147  /// This class provides an efficient implementation of \c Bellman-Ford
    148148  /// algorithm. The edge lengths are passed to the algorithm using a
    149   /// \ref concept::ReadMap "ReadMap", so it is easy to change it to any
     149  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
    150150  /// kind of length.
    151151  ///
     
    159159  ///
    160160  /// The type of the length is determined by the
    161   /// \ref concept::ReadMap::Value "Value" of the length map.
     161  /// \ref concepts::ReadMap::Value "Value" of the length map.
    162162  ///
    163163  /// \param _Graph The graph type the algorithm runs on. The default value
     
    165165  /// BellmanFord, it is only passed to \ref BellmanFordDefaultTraits.
    166166  /// \param _LengthMap This read-only EdgeMap determines the lengths of the
    167   /// edges. The default map type is \ref concept::Graph::EdgeMap
     167  /// edges. The default map type is \ref concepts::Graph::EdgeMap
    168168  /// "Graph::EdgeMap<int>".  The value of _LengthMap is not used directly
    169169  /// by BellmanFord, it is only passed to \ref BellmanFordDefaultTraits. 
     
    791791    ///
    792792    /// The type of the map that stores the edge lengths.
    793     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     793    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    794794    typedef _LengthMap LengthMap;
    795795
     
    809809    /// The type of the map that stores the last
    810810    /// edges of the shortest paths.
    811     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     811    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    812812    typedef NullMap <typename _Graph::Node,typename _Graph::Edge> PredMap;
    813813
     
    821821    ///
    822822    /// The type of the map that stores the dists of the nodes.
    823     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     823    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    824824    typedef NullMap<typename Graph::Node, Value> DistMap;
    825825    /// \brief Instantiates a DistMap.
  • lemon/bfs.h

    r2151 r2260  
    4848    ///The type of the map that stores the last
    4949    ///edges of the shortest paths.
    50     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     50    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5151    ///
    5252    typedef typename Graph::template NodeMap<typename GR::Edge> PredMap;
     
    6363 
    6464    ///The type of the map that indicates which nodes are processed.
    65     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     65    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6666    ///\todo named parameter to set this type, function to read and write.
    6767    typedef NullMap<typename Graph::Node,bool> ProcessedMap;
     
    8282 
    8383    ///The type of the map that indicates which nodes are reached.
    84     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     84    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    8585    ///\todo named parameter to set this type, function to read and write.
    8686    typedef typename Graph::template NodeMap<bool> ReachedMap;
     
    9797 
    9898    ///The type of the map that stores the dists of the nodes.
    99     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     99    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    100100    ///
    101101    typedef typename Graph::template NodeMap<int> DistMap;
     
    706706    ///The type of the map that stores the last
    707707    ///edges of the shortest paths.
    708     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     708    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    709709    ///
    710710    typedef NullMap<typename Graph::Node,typename GR::Edge> PredMap;
     
    726726 
    727727    ///The type of the map that indicates which nodes are processed.
    728     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     728    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    729729    ///\todo named parameter to set this type, function to read and write.
    730730    typedef NullMap<typename Graph::Node,bool> ProcessedMap;
     
    745745 
    746746    ///The type of the map that indicates which nodes are reached.
    747     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     747    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    748748    ///\todo named parameter to set this type, function to read and write.
    749749    typedef typename Graph::template NodeMap<bool> ReachedMap;
     
    760760 
    761761    ///The type of the map that stores the dists of the nodes.
    762     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     762    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    763763    ///
    764764    typedef NullMap<typename Graph::Node,int> DistMap;
  • lemon/bits/array_map.h

    r2202 r2260  
    2525#include <lemon/bits/alteration_notifier.h>
    2626#include <lemon/concept_check.h>
    27 #include <lemon/concept/maps.h>
     27#include <lemon/concepts/maps.h>
    2828
    2929/// \ingroup graphbits
     
    142142    template <typename CMap>
    143143    ArrayMap& operator=(const CMap& cmap) {
    144       checkConcept<concept::ReadMap<Key, _Value>, CMap>();
     144      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
    145145      const typename Parent::Notifier* notifier = Parent::getNotifier();
    146146      Item it;
  • lemon/bits/base_extender.h

    r2231 r2260  
    2727
    2828#include <lemon/concept_check.h>
    29 #include <lemon/concept/maps.h>
     29#include <lemon/concepts/maps.h>
    3030
    3131///\ingroup graphbits
  • lemon/bits/debug_map.h

    r2202 r2260  
    3030
    3131#include <lemon/concept_check.h>
    32 #include <lemon/concept/maps.h>
     32#include <lemon/concepts/maps.h>
    3333
    3434///\ingroup graphbits
     
    187187    template <typename CMap>
    188188    DebugMap& operator=(const CMap& cmap) {
    189       checkConcept<concept::ReadMap<Key, _Value>, CMap>();
     189      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
    190190      const typename Parent::Notifier* notifier = Parent::getNotifier();
    191191      Item it;
  • lemon/bits/graph_extender.h

    r2231 r2260  
    2727
    2828#include <lemon/concept_check.h>
    29 #include <lemon/concept/maps.h>
     29#include <lemon/concepts/maps.h>
    3030
    3131///\ingroup graphbits
     
    11291129      template <typename CMap>
    11301130      NodeMap& operator=(const CMap& cmap) {
    1131         checkConcept<concept::ReadMap<Node, _Value>, CMap>();
     1131        checkConcept<concepts::ReadMap<Node, _Value>, CMap>();
    11321132        aNodeMap = cmap;
    11331133        bNodeMap = cmap;
  • lemon/bits/map_extender.h

    r2031 r2260  
    2525
    2626#include <lemon/concept_check.h>
    27 #include <lemon/concept/maps.h>
     27#include <lemon/concepts/maps.h>
    2828
    2929///\file
     
    207207    template <typename CMap>
    208208    SubMapExtender& operator=(const CMap& cmap) {
    209       checkConcept<concept::ReadMap<Key, Value>, CMap>();
     209      checkConcept<concepts::ReadMap<Key, Value>, CMap>();
    210210      Item it;
    211211      for (graph.first(it); it != INVALID; graph.next(it)) {
  • lemon/bits/vector_map.h

    r2202 r2260  
    2929
    3030#include <lemon/concept_check.h>
    31 #include <lemon/concept/maps.h>
     31#include <lemon/concepts/maps.h>
    3232
    3333///\ingroup graphbits
     
    134134    template <typename CMap>
    135135    VectorMap& operator=(const CMap& cmap) {
    136       checkConcept<concept::ReadMap<Key, _Value>, CMap>();
     136      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
    137137      const typename Parent::Notifier* notifier = Parent::getNotifier();
    138138      Item it;
  • lemon/color.h

    r2230 r2260  
    101101///number. The integer range is cyclically mapped to the provided set of colors.
    102102///
    103 ///This is a true \ref concept::ReferenceMap "reference map", so you can also
     103///This is a true \ref concepts::ReferenceMap "reference map", so you can also
    104104///change the actual colors.
    105105
  • lemon/dag_shortest_path.h

    r2151 r2260  
    9494    ///
    9595    /// The type of the map that stores the edge lengths.
    96     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     96    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    9797    typedef _LengthMap LengthMap;
    9898
     
    112112    /// The type of the map that stores the last
    113113    /// edges of the shortest paths.
    114     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     114    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    115115    ///
    116116    typedef typename Graph::template NodeMap<typename _Graph::Edge> PredMap;
     
    129129    ///
    130130    /// The type of the map that stores the dists of the nodes.
    131     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     131    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    132132    ///
    133133    typedef typename Graph::template NodeMap<typename _LengthMap::Value>
     
    206206    ///
    207207    /// The type of the map that stores the edge lengths.
    208     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     208    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    209209    typedef _LengthMap LengthMap;
    210210
     
    224224    /// The type of the map that stores the last
    225225    /// edges of the longest paths.
    226     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     226    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    227227    ///
    228228    typedef typename Graph::template NodeMap<typename _Graph::Edge> PredMap;
     
    241241    ///
    242242    /// The type of the map that stores the dists of the nodes.
    243     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     243    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    244244    ///
    245245    typedef typename Graph::template NodeMap<typename _LengthMap::Value>
     
    263263  /// This class provides an efficient implementation of a Dag sortest path
    264264  /// searching algorithm. The edge lengths are passed to the algorithm
    265   /// using a \ref concept::ReadMap "ReadMap", so it is easy to change it
     265  /// using a \ref concepts::ReadMap "ReadMap", so it is easy to change it
    266266  /// to any kind of length.
    267267  ///
     
    269269  ///
    270270  /// The type of the length is determined by the
    271   /// \ref concept::ReadMap::Value "Value" of the length map.
     271  /// \ref concepts::ReadMap::Value "Value" of the length map.
    272272  ///
    273273  /// \param _Graph The graph type the algorithm runs on. The default value
     
    275275  /// DagShortestPath, it is only passed to \ref DagShortestPathDefaultTraits.
    276276  /// \param _LengthMap This read-only EdgeMap determines the lengths of the
    277   /// edges. The default map type is \ref concept::Graph::EdgeMap
     277  /// edges. The default map type is \ref concepts::Graph::EdgeMap
    278278  /// "Graph::EdgeMap<int>".  The value of _LengthMap is not used directly
    279279  /// by DagShortestPath, it is only passed to \ref DagShortestPathDefaultTraits. 
     
    812812    ///
    813813    /// The type of the map that stores the edge lengths.
    814     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     814    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    815815    typedef _LengthMap LengthMap;
    816816
     
    830830    /// The type of the map that stores the last
    831831    /// edges of the shortest paths.
    832     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     832    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    833833    typedef NullMap <typename _Graph::Node,typename _Graph::Edge> PredMap;
    834834
     
    842842    ///
    843843    /// The type of the map that stores the dists of the nodes.
    844     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     844    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    845845    typedef NullMap<typename Graph::Node, Value> DistMap;
    846846    /// \brief Instantiates a DistMap.
  • lemon/dfs.h

    r2156 r2260  
    4949    ///The type of the map that stores the last
    5050    ///edges of the %DFS paths.
    51     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     51    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5252    ///
    5353    typedef typename Graph::template NodeMap<typename GR::Edge> PredMap;
     
    6565 
    6666    ///The type of the map that indicates which nodes are processed.
    67     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     67    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6868    ///\todo named parameter to set this type, function to read and write.
    6969    typedef NullMap<typename Graph::Node,bool> ProcessedMap;
     
    8484 
    8585    ///The type of the map that indicates which nodes are reached.
    86     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     86    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    8787    ///\todo named parameter to set this type, function to read and write.
    8888    typedef typename Graph::template NodeMap<bool> ReachedMap;
     
    9999 
    100100    ///The type of the map that stores the dists of the nodes.
    101     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     101    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    102102    ///
    103103    typedef typename Graph::template NodeMap<int> DistMap;
     
    753753    ///The type of the map that stores the last
    754754    ///edges of the %DFS paths.
    755     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     755    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    756756    ///
    757757    typedef NullMap<typename Graph::Node,typename GR::Edge> PredMap;
     
    773773 
    774774    ///The type of the map that indicates which nodes are processed.
    775     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     775    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    776776    ///\todo named parameter to set this type, function to read and write.
    777777    typedef NullMap<typename Graph::Node,bool> ProcessedMap;
     
    792792 
    793793    ///The type of the map that indicates which nodes are reached.
    794     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     794    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    795795    ///\todo named parameter to set this type, function to read and write.
    796796    typedef typename Graph::template NodeMap<bool> ReachedMap;
     
    807807 
    808808    ///The type of the map that stores the dists of the nodes.
    809     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     809    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    810810    ///
    811811    typedef NullMap<typename Graph::Node,int> DistMap;
     
    11691169    ///
    11701170    /// The type of the map that indicates which nodes are reached.
    1171     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     1171    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    11721172    /// \todo named parameter to set this type, function to read and write.
    11731173    typedef typename Graph::template NodeMap<bool> ReachedMap;
  • lemon/dijkstra.h

    r2230 r2260  
    4949
    5050    ///The type of the map that stores the edge lengths.
    51     ///It must meet the \ref concept::ReadMap "ReadMap" concept.
     51    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
    5252    typedef LM LengthMap;
    5353    //The type of the length of the edges.
     
    8787    ///The type of the map that stores the last
    8888    ///edges of the shortest paths.
    89     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     89    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    9090    ///
    9191    typedef typename Graph::template NodeMap<typename GR::Edge> PredMap;
     
    103103 
    104104    ///The type of the map that stores whether a nodes is processed.
    105     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     105    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    106106    ///By default it is a NullMap.
    107107    ///\todo If it is set to a real map,
     
    125125 
    126126    ///The type of the map that stores the dists of the nodes.
    127     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     127    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    128128    ///
    129129    typedef typename Graph::template NodeMap<typename LM::Value> DistMap;
     
    143143  ///This class provides an efficient implementation of %Dijkstra algorithm.
    144144  ///The edge lengths are passed to the algorithm using a
    145   ///\ref concept::ReadMap "ReadMap",
     145  ///\ref concepts::ReadMap "ReadMap",
    146146  ///so it is easy to change it to any kind of length.
    147147  ///
    148148  ///The type of the length is determined by the
    149   ///\ref concept::ReadMap::Value "Value" of the length map.
     149  ///\ref concepts::ReadMap::Value "Value" of the length map.
    150150  ///
    151151  ///It is also possible to change the underlying priority heap.
     
    158158  ///relatively time consuming process to compute the edge length if
    159159  ///it is necessary. The default map type is \ref
    160   ///concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
     160  ///concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
    161161  ///of LM is not used directly by Dijkstra, it is only passed to \ref
    162162  ///DijkstraDefaultTraits.  \param TR Traits class to set
     
    820820
    821821    ///The type of the map that stores the edge lengths.
    822     ///It must meet the \ref concept::ReadMap "ReadMap" concept.
     822    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
    823823    typedef LM LengthMap;
    824824    //The type of the length of the edges.
     
    862862    ///The type of the map that stores the last
    863863    ///edges of the shortest paths.
    864     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     864    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    865865    ///
    866866    typedef NullMap <typename GR::Node,typename GR::Edge> PredMap;
     
    881881 
    882882    ///The type of the map that stores whether a nodes is processed.
    883     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     883    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    884884    ///By default it is a NullMap.
    885885    ///\todo If it is set to a real map,
     
    903903 
    904904    ///The type of the map that stores the dists of the nodes.
    905     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     905    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    906906    ///
    907907    typedef NullMap<typename Graph::Node,typename LM::Value> DistMap;
  • lemon/edge_set.h

    r2224 r2260  
    239239  ///
    240240  /// \param _Graph The type of the graph which shares its node set with
    241   /// this class. Its interface must conform to the \ref concept::Graph
     241  /// this class. Its interface must conform to the \ref concepts::Graph
    242242  /// "Graph" concept.
    243243  ///
    244244  /// In the edge extension and removing it conforms to the
    245   /// \ref concept::Graph "Graph" concept.
     245  /// \ref concepts::Graph "Graph" concept.
    246246  template <typename _Graph>
    247247  class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<_Graph> > {
     
    331331  ///
    332332  /// \param _Graph The type of the graph which shares its node set with
    333   /// this class. Its interface must conform to the \ref concept::Graph
     333  /// this class. Its interface must conform to the \ref concepts::Graph
    334334  /// "Graph" concept.
    335335  ///
    336336  /// In the edge extension and removing it conforms to the
    337   /// \ref concept::UGraph "UGraph" concept.
     337  /// \ref concepts::UGraph "UGraph" concept.
    338338  template <typename _Graph>
    339339  class ListUEdgeSet
     
    568568  ///
    569569  /// \param _Graph The type of the graph which shares its node set with
    570   /// this class. Its interface must conform to the \ref concept::Graph
     570  /// this class. Its interface must conform to the \ref concepts::Graph
    571571  /// "Graph" concept.
    572572  ///
    573573  /// In the edge extension and removing it conforms to the
    574   /// \ref concept::Graph "Graph" concept.
     574  /// \ref concepts::Graph "Graph" concept.
    575575  template <typename _Graph>
    576576  class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<_Graph> > {
     
    672672  ///
    673673  /// \param _Graph The type of the graph which shares its node set with
    674   /// this class. Its interface must conform to the \ref concept::Graph
     674  /// this class. Its interface must conform to the \ref concepts::Graph
    675675  /// "Graph" concept.
    676676  ///
    677677  /// In the edge extension and removing it conforms to the
    678   /// \ref concept::UGraph "UGraph" concept.
     678  /// \ref concepts::UGraph "UGraph" concept.
    679679  template <typename _Graph>
    680680  class SmartUEdgeSet
  • lemon/floyd_warshall.h

    r2184 r2260  
    9595    ///
    9696    /// The type of the map that stores the edge lengths.
    97     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     97    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    9898    typedef _LengthMap LengthMap;
    9999
     
    130130    ///
    131131    /// The type of the map that stores the dists of the nodes.
    132     /// It must meet the \ref concept::WriteMatrixMap "WriteMatrixMap" concept.
     132    /// It must meet the \ref concepts::WriteMatrixMap "WriteMatrixMap" concept.
    133133    ///
    134134    typedef DynamicMatrixMap<Graph, typename Graph::Node, Value> DistMap;
     
    150150  /// This class provides an efficient implementation of \c Floyd-Warshall
    151151  /// algorithm. The edge lengths are passed to the algorithm using a
    152   /// \ref concept::ReadMap "ReadMap", so it is easy to change it to any
     152  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
    153153  /// kind of length.
    154154  ///
     
    163163  ///
    164164  /// The type of the length is determined by the
    165   /// \ref concept::ReadMap::Value "Value" of the length map.
     165  /// \ref concepts::ReadMap::Value "Value" of the length map.
    166166  ///
    167167  /// \param _Graph The graph type the algorithm runs on. The default value
     
    172172  /// relatively time consuming process to compute the edge length if
    173173  /// it is necessary. The default map type is \ref
    174   /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
     174  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
    175175  /// of _LengthMap is not used directly by FloydWarshall, it is only passed
    176176  /// to \ref FloydWarshallDefaultTraits.  \param _Traits Traits class to set
  • lemon/fredman_tarjan.h

    r2151 r2260  
    3737#include <lemon/graph_utils.h>
    3838
    39 #include <lemon/concept/ugraph.h>
     39#include <lemon/concepts/ugraph.h>
    4040
    4141namespace lemon {
     
    5353
    5454    ///The type of the map that stores the edge costs.
    55     ///It must meet the \ref concept::ReadMap "ReadMap" concept.
     55    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
    5656    typedef CM CostMap;
    5757    //The type of the cost of the edges.
     
    6262    ///The type of the map that stores whether an edge is in the
    6363    ///spanning tree or not.
    64     ///It must meet the \ref concept::ReadWriteMap "ReadWriteMap" concept.
     64    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    6565    ///By default it is a BoolEdgeMap.
    6666    typedef typename UGraph::template UEdgeMap<bool> TreeMap;
     
    8989  ///
    9090  ///The edge costs are passed to the algorithm using a \ref
    91   ///concept::ReadMap "ReadMap", so it is easy to change it to any
     91  ///concepts::ReadMap "ReadMap", so it is easy to change it to any
    9292  ///kind of cost.
    9393  ///
    9494  ///The type of the cost is determined by the \ref
    95   ///concept::ReadMap::Value "Value" of the cost map.
     95  ///concepts::ReadMap::Value "Value" of the cost map.
    9696  ///
    9797  ///\param GR The graph type the algorithm runs on. The default value
     
    104104  ///relatively time consuming process to compute the edge cost if it
    105105  ///is necessary. The default map type is \ref
    106   ///concept::UGraph::UEdgeMap "UGraph::UEdgeMap<int>". The value of
     106  ///concepts::UGraph::UEdgeMap "UGraph::UEdgeMap<int>". The value of
    107107  ///CM is not used directly by FredmanTarjan, it is only passed to
    108108  ///\ref FredmanTarjanDefaultTraits.
     
    366366      _tree(0), local_tree(false)
    367367    {
    368       checkConcept<concept::UGraph, UGraph>();
     368      checkConcept<concepts::UGraph, UGraph>();
    369369    }
    370370   
  • lemon/full_graph.h

    r2256 r2260  
    168168  /// edges or nodes.
    169169  /// Thus it conforms to
    170   /// the \ref concept::Graph "Graph" concept and
     170  /// the \ref concepts::Graph "Graph" concept and
    171171  ///it also has an
    172172  ///important extra feature that
    173   ///its maps are real \ref concept::ReferenceMap "reference map"s.
    174   /// \sa concept::Graph.
     173  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
     174  /// \sa concepts::Graph.
    175175  ///
    176176  /// \sa FullUGraph
     
    385385  ///It also has an
    386386  ///important extra feature that
    387   ///its maps are real \ref concept::ReferenceMap "reference map"s.
     387  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
    388388  ///
    389389  /// \sa FullGraph
  • lemon/graph_adaptor.h

    r2251 r2260  
    24932493  ///
    24942494  /// This graph adaptor is fully conform to the
    2495   /// \ref concept::Graph "Graph" concept and
     2495  /// \ref concepts::Graph "Graph" concept and
    24962496  /// contains some additional member functions and types. The
    24972497  /// documentation of some member functions may be found just in the
  • lemon/grid_ugraph.h

    r2256 r2260  
    293293  ///\endcode
    294294  ///
    295   /// The graph type is fully conform to the \ref concept::UGraph
     295  /// The graph type is fully conform to the \ref concepts::UGraph
    296296  /// "Undirected Graph" concept,  and it also has an
    297297  ///important extra feature that
    298   ///its maps are real \ref concept::ReferenceMap "reference map"s.
     298  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
    299299  ///
    300300  ///
  • lemon/hypercube_graph.h

    r2242 r2260  
    190190  /// is 26.
    191191  ///
    192   /// The graph type is fully conform to the \ref concept::Graph
    193   /// concept but it does not conform to the \ref concept::UGraph.
     192  /// The graph type is fully conform to the \ref concepts::Graph
     193  /// concept but it does not conform to the \ref concepts::UGraph.
    194194  ///
    195195  /// \author Balazs Dezso
  • lemon/johnson.h

    r2230 r2260  
    9797    ///
    9898    /// The type of the map that stores the edge lengths.
    99     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     99    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    100100    typedef _LengthMap LengthMap;
    101101
     
    163163    ///
    164164    /// The type of the matrix map that stores the dists of the nodes.
    165     /// It must meet the \ref concept::WriteMatrixMap "WriteMatrixMap" concept.
     165    /// It must meet the \ref concepts::WriteMatrixMap "WriteMatrixMap" concept.
    166166    ///
    167167    typedef DynamicMatrixMap<Graph, typename Graph::Node, Value> DistMap;
     
    183183  /// This class provides an efficient implementation of \c %Johnson
    184184  /// algorithm. The edge lengths are passed to the algorithm using a
    185   /// \ref concept::ReadMap "ReadMap", so it is easy to change it to any
     185  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
    186186  /// kind of length.
    187187  ///
     
    198198  ///
    199199  /// The type of the length is determined by the
    200   /// \ref concept::ReadMap::Value "Value" of the length map.
     200  /// \ref concepts::ReadMap::Value "Value" of the length map.
    201201  ///
    202202  /// \param _Graph The graph type the algorithm runs on. The default value
     
    207207  /// relatively time consuming process to compute the edge length if
    208208  /// it is necessary. The default map type is \ref
    209   /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
     209  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
    210210  /// of _LengthMap is not used directly by Johnson, it is only passed
    211211  /// to \ref JohnsonDefaultTraits.  \param _Traits Traits class to set
  • lemon/kruskal.h

    r2259 r2260  
    4545  ///
    4646  /// \param g The graph the algorithm runs on.
    47   /// It can be either \ref concept::Graph "directed" or
    48   /// \ref concept::UGraph "undirected".
     47  /// It can be either \ref concepts::Graph "directed" or
     48  /// \ref concepts::UGraph "undirected".
    4949  /// If the graph is directed, the algorithm consider it to be
    5050  /// undirected by disregarding the direction of the edges.
     
    8484  ///
    8585  /// \warning If kruskal runs on an
    86   /// \ref lemon::concept::UGraph "undirected graph", be sure that the
     86  /// \ref lemon::concepts::UGraph "undirected graph", be sure that the
    8787  /// map storing the tree is also undirected
    8888  /// (e.g. ListUGraph::UEdgeMap<bool>, otherwise the values of the
  • lemon/lemon_reader.h

    r2207 r2260  
    4242
    4343#include <lemon/concept_check.h>
    44 #include <lemon/concept/maps.h>
     44#include <lemon/concepts/maps.h>
    4545
    4646namespace lemon {
     
    832832    NodeSetReader& _readMap(std::string name, MapParameter map,
    833833                            const Reader& reader = Reader()) {
    834       checkConcept<concept::WriteMap<Node, typename Map::Value>, Map>();
     834      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
    835835      checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    836836      if (readers.find(name) != readers.end()) {
     
    10621062    EdgeSetReader& _readMap(std::string name, MapParameter map,
    10631063                            const Reader& reader = Reader()) {
    1064       checkConcept<concept::WriteMap<Edge, typename Map::Value>, Map>();
     1064      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
    10651065      checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    10661066      if (readers.find(name) != readers.end()) {
     
    13061306    UEdgeSetReader& _readMap(std::string name, MapParameter map,
    13071307                                 const Reader& reader = Reader()) {
    1308       checkConcept<concept::WriteMap<UEdge, typename Map::Value>, Map>();
     1308      checkConcept<concepts::WriteMap<UEdge, typename Map::Value>, Map>();
    13091309      checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    13101310      if (readers.find(name) != readers.end()) {
     
    13771377                                    const Reader& reader = Reader()) {
    13781378      checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    1379       checkConcept<concept::WriteMap<Edge, typename Map::Value>, Map>();
     1379      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
    13801380      readMap("+" + name,
    13811381              _reader_bits::forwardComposeMap(graph, map), reader);
  • lemon/lemon_writer.h

    r2207 r2260  
    4141
    4242#include <lemon/concept_check.h>
    43 #include <lemon/concept/maps.h>
     43#include <lemon/concepts/maps.h>
    4444
    4545
     
    484484    NodeSetWriter& writeNodeMap(std::string name, const Map& map,
    485485                            const Writer& writer = Writer()) {
    486       checkConcept<concept::ReadMap<Node, typename Map::Value>, Map>();
     486      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
    487487      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
    488488      writers.push_back(
     
    673673    EdgeSetWriter& writeEdgeMap(std::string name, const Map& map,
    674674                            const Writer& writer = Writer()) {
    675       checkConcept<concept::ReadMap<Edge, typename Map::Value>, Map>();
     675      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
    676676      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
    677677      writers.push_back(
     
    879879    UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map,
    880880                                          const Writer& writer = Writer()) {
    881       checkConcept<concept::ReadMap<UEdge, typename Map::Value>, Map>();
     881      checkConcept<concepts::ReadMap<UEdge, typename Map::Value>, Map>();
    882882      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
    883883      writers.push_back(
     
    902902    UEdgeSetWriter& writeEdgeMap(std::string name, const Map& map,
    903903                                     const Writer& writer = Writer()) {
    904       checkConcept<concept::ReadMap<Edge, typename Map::Value>, Map>();
     904      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
    905905      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
    906906      writeUEdge("+" + name,
  • lemon/list_graph.h

    r2256 r2260  
    319319  ///This is a simple and fast graph implementation.
    320320  ///
    321   ///It conforms to the \ref concept::Graph "Graph concept" and it
     321  ///It conforms to the \ref concepts::Graph "Graph concept" and it
    322322  ///also provides several additional useful extra functionalities.
    323323  ///The most of the member functions and nested classes are
     
    325325  ///
    326326  ///An important extra feature of this graph implementation is that
    327   ///its maps are real \ref concept::ReferenceMap "reference map"s.
     327  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
    328328  ///
    329   ///\sa concept::Graph.
     329  ///\sa concepts::Graph.
    330330
    331331  class ListGraph : public ExtendedListGraphBase {
     
    749749  ///
    750750  ///An important extra feature of this graph implementation is that
    751   ///its maps are real \ref concept::ReferenceMap "reference map"s.
     751  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
    752752  ///
    753753  ///It conforms to the
    754   ///\ref concept::UGraph "UGraph concept".
     754  ///\ref concepts::UGraph "UGraph concept".
    755755  ///
    756   ///\sa concept::UGraph.
     756  ///\sa concepts::UGraph.
    757757  ///
    758758  class ListUGraph : public ExtendedListUGraphBase {
     
    14981498  ///
    14991499  /// This is a bipartite undirected graph implementation.
    1500   /// It is conforms to the \ref concept::BpUGraph "BpUGraph concept".
     1500  /// It is conforms to the \ref concepts::BpUGraph "BpUGraph concept".
    15011501  ///
    15021502  ///An important extra feature of this graph implementation is that
    1503   ///its maps are real \ref concept::ReferenceMap "reference map"s.
     1503  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
    15041504  ///
    1505   /// \sa concept::BpUGraph.
     1505  /// \sa concepts::BpUGraph.
    15061506  ///
    15071507  class ListBpUGraph : public ExtendedListBpUGraphBase {
  • lemon/lp_base.h

    r2218 r2260  
    666666    ///std::map<AnyType,LpSolverBase::Col>
    667667    ///\endcode
    668     ///- an iterable lemon \ref concept::WriteMap "write map" like
     668    ///- an iterable lemon \ref concepts::WriteMap "write map" like
    669669    ///\code
    670670    ///ListGraph::NodeMap<LpSolverBase::Col>
     
    766766    ///std::map<AnyType,LpSolverBase::Row>
    767767    ///\endcode
    768     ///- an iterable lemon \ref concept::WriteMap "write map" like
     768    ///- an iterable lemon \ref concepts::WriteMap "write map" like
    769769    ///\code
    770770    ///ListGraph::NodeMap<LpSolverBase::Row>
  • lemon/maps.h

    r2258 r2260  
    3030///\brief Miscellaneous property maps
    3131///
    32 ///\todo This file has the same name as the concept file in concept/,
     32///\todo This file has the same name as the concept file in concepts/,
    3333/// and this is not easily detectable in docs...
    3434
     
    253253  ///Convert the \c Value of a map to another type.
    254254
    255   ///This \ref concept::ReadMap "read only map"
     255  ///This \ref concepts::ReadMap "read only map"
    256256  ///converts the \c Value of a maps to type \c T.
    257257  ///Its \c Key is inherited from \c M.
     
    290290  ///Simple wrapping of the map
    291291
    292   ///This \ref concept::ReadMap "read only map" returns the simple
     292  ///This \ref concepts::ReadMap "read only map" returns the simple
    293293  ///wrapping of the given map. Sometimes the reference maps cannot be
    294294  ///combined with simple read maps. This map adaptor wraps the given
     
    310310  ///Simple writeable wrapping of the map
    311311
    312   ///This \ref concept::ReadMap "read only map" returns the simple
     312  ///This \ref concepts::ReadMap "read only map" returns the simple
    313313  ///wrapping of the given map. Sometimes the reference maps cannot be
    314314  ///combined with simple read-write maps. This map adaptor wraps the
     
    331331  ///Sum of two maps
    332332
    333   ///This \ref concept::ReadMap "read only map" returns the sum of the two
     333  ///This \ref concepts::ReadMap "read only map" returns the sum of the two
    334334  ///given maps. Its \c Key and \c Value will be inherited from \c M1.
    335335  ///The \c Key and \c Value of M2 must be convertible to those of \c M1.
     
    364364  ///Shift a map with a constant.
    365365
    366   ///This \ref concept::ReadMap "read only map" returns the sum of the
     366  ///This \ref concepts::ReadMap "read only map" returns the sum of the
    367367  ///given map and a constant value.
    368368  ///Its \c Key and \c Value is inherited from \c M.
     
    397397  ///Shift a map with a constant.
    398398
    399   ///This \ref concept::ReadWriteMap "read-write map" returns the sum of the
     399  ///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
    400400  ///given map and a constant value. It makes also possible to write the map.
    401401  ///Its \c Key and \c Value is inherited from \c M.
     
    446446  ///Difference of two maps
    447447
    448   ///This \ref concept::ReadMap "read only map" returns the difference
     448  ///This \ref concepts::ReadMap "read only map" returns the difference
    449449  ///of the values of the two
    450450  ///given maps. Its \c Key and \c Value will be inherited from \c M1.
     
    477477  ///Product of two maps
    478478
    479   ///This \ref concept::ReadMap "read only map" returns the product of the
     479  ///This \ref concepts::ReadMap "read only map" returns the product of the
    480480  ///values of the two
    481481  ///given
     
    508508  ///Scales a maps with a constant.
    509509
    510   ///This \ref concept::ReadMap "read only map" returns the value of the
     510  ///This \ref concepts::ReadMap "read only map" returns the value of the
    511511  ///given map multiplied from the left side with a constant value.
    512512  ///Its \c Key and \c Value is inherited from \c M.
     
    541541  ///Scales a maps with a constant.
    542542
    543   ///This \ref concept::ReadWriteMap "read-write map" returns the value of the
     543  ///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
    544544  ///given map multiplied from the left side with a constant value. It can
    545545  ///be used as write map also if the given multiplier is not zero.
     
    581581  ///Quotient of two maps
    582582
    583   ///This \ref concept::ReadMap "read only map" returns the quotient of the
     583  ///This \ref concepts::ReadMap "read only map" returns the quotient of the
    584584  ///values of the two
    585585  ///given maps. Its \c Key and \c Value will be inherited from \c M1.
     
    611611  ///Composition of two maps
    612612
    613   ///This \ref concept::ReadMap "read only map" returns the composition of
     613  ///This \ref concepts::ReadMap "read only map" returns the composition of
    614614  ///two
    615615  ///given maps. That is to say, if \c m1 is of type \c M1 and \c m2 is
     
    656656  ///
    657657  ///
    658   ///This \ref concept::ReadMap "read only map" takes two maps and a
     658  ///This \ref concepts::ReadMap "read only map" takes two maps and a
    659659  ///binary functor and returns the composition of
    660660  ///the two
     
    728728  ///Negative value of a map
    729729
    730   ///This \ref concept::ReadMap "read only map" returns the negative
     730  ///This \ref concepts::ReadMap "read only map" returns the negative
    731731  ///value of the
    732732  ///value returned by the
     
    749749  ///Negative value of a map
    750750
    751   ///This \ref concept::ReadWriteMap "read-write map" returns the negative
     751  ///This \ref concepts::ReadWriteMap "read-write map" returns the negative
    752752  ///value of the value returned by the
    753753  ///given map. Its \c Key and \c Value will be inherited from \c M.
     
    784784  ///Absolute value of a map
    785785
    786   ///This \ref concept::ReadMap "read only map" returns the absolute value
     786  ///This \ref concepts::ReadMap "read only map" returns the absolute value
    787787  ///of the
    788788  ///value returned by the
     
    833833  ///Converts an STL style functor to a map
    834834
    835   ///This \ref concept::ReadMap "read only map" returns the value
     835  ///This \ref concepts::ReadMap "read only map" returns the value
    836836  ///of a
    837837  ///given map.
     
    891891  ///
    892892  ///For the sake of convenience it also works as
    893   ///a ususal \ref concept::ReadMap "readable map",
     893  ///a ususal \ref concepts::ReadMap "readable map",
    894894  ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
    895895
     
    926926  ///Applies all map setting operations to two maps
    927927
    928   ///This map has two \ref concept::ReadMap "readable map"
     928  ///This map has two \ref concepts::ReadMap "readable map"
    929929  ///parameters and each read request will be passed just to the
    930930  ///first map. This class is the just readable map type of the ForkWriteMap.
     
    950950  ///Applies all map setting operations to two maps
    951951
    952   ///This map has two \ref concept::WriteMap "writable map"
     952  ///This map has two \ref concepts::WriteMap "writable map"
    953953  ///parameters and each write request will be passed to both of them.
    954   ///If \c M1 is also \ref concept::ReadMap "readable",
     954  ///If \c M1 is also \ref concepts::ReadMap "readable",
    955955  ///then the read operations will return the
    956956  ///corresponding values of \c M1.
     
    997997  ///Logical 'not' of a map
    998998 
    999   ///This bool \ref concept::ReadMap "read only map" returns the
     999  ///This bool \ref concepts::ReadMap "read only map" returns the
    10001000  ///logical negation of
    10011001  ///value returned by the
     
    10181018  ///Logical 'not' of a map with writing possibility
    10191019 
    1020   ///This bool \ref concept::ReadWriteMap "read-write map" returns the
     1020  ///This bool \ref concepts::ReadWriteMap "read-write map" returns the
    10211021  ///logical negation of value returned by the given map. When it is set,
    10221022  ///the opposite value is set to the original map.
  • lemon/matrix_maps.h

    r2088 r2260  
    2626#include <lemon/maps.h>
    2727
    28 #include <lemon/concept/matrix_maps.h>
     28#include <lemon/concepts/matrix_maps.h>
    2929
    3030/// \file
     
    3232/// \brief Maps indexed with pairs of items.
    3333///
    34 /// \todo This file has the same name as the concept file in concept/,
     34/// \todo This file has the same name as the concept file in concepts/,
    3535///  and this is not easily detectable in docs...
    3636namespace lemon {
     
    296296    template <typename CMap>
    297297    DynamicMatrixMap& operator=(const CMap& _cmap){
    298       checkConcept<concept::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
     298      checkConcept<concepts::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
    299299      typename Parent::Notifier* notifier = Parent::getNotifier();
    300300      Key first, second;
     
    433433    template <typename CMap>
    434434    DynamicSymMatrixMap& operator=(const CMap& _cmap){
    435       checkConcept<concept::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
     435      checkConcept<concepts::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
    436436      typename Parent::Notifier* notifier = Parent::getNotifier();
    437437      Key first, second;
     
    520520  ///needed.
    521521  ///
    522   ///This map meet with the concept::ReferenceMatrixMap<typename K1,
     522  ///This map meet with the concepts::ReferenceMatrixMap<typename K1,
    523523  ///typename K2, typename V, typename R, typename CR> called as
    524524  ///"ReferenceMatrixMap".
     
    861861    template <typename CMap>
    862862    DynamicAsymMatrixMap& operator=(const CMap& _cdmap){
    863       checkConcept<concept::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
     863      checkConcept<concepts::ReadMatrixMap<FirstKey, SecondKey, Value>, CMap>();
    864864      const typename FirstKeyProxy::Notifier* notifierFirstKey =
    865865        _first_key_proxy.getNotifier();
  • lemon/min_cost_arborescence.h

    r2259 r2260  
    4646    ///
    4747    /// The type of the map that stores the edge costs.
    48     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     48    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    4949    typedef _CostMap CostMap;
    5050
     
    5858    ///
    5959    /// The type of the map that stores which edges are in the arborescence.
    60     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     60    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6161    /// Initially it will be set to false on each edge. After it
    6262    /// will set all arborescence edges once.
     
    111111  /// relatively time consuming process to compute the edge cost if
    112112  /// it is necessary. The default map type is \ref
    113   /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
     113  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
    114114  /// of _CostMap is not used directly by MinCostArborescence,
    115115  /// it is only passed to \ref MinCostArborescenceDefaultTraits. 
  • lemon/min_cut.h

    r2225 r2260  
    6868    ///
    6969    /// The type of the map that stores the edge capacities.
    70     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     70    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    7171    typedef _CapacityMap CapacityMap;
    7272
     
    114114    ///
    115115    /// The type of the map that stores whether a nodes is processed.
    116     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     116    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    117117    /// By default it is a NullMap.
    118118    typedef NullMap<typename Graph::Node, bool> ProcessedMap;
     
    135135    ///
    136136    /// The type of the map that stores the cardinalities of the nodes.
    137     /// It must meet the \ref concept::WriteMap "WriteMap" concept.
     137    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
    138138    typedef typename Graph::template NodeMap<Value> CardinalityMap;
    139139
     
    163163  ///
    164164  /// The edge capacities are passed to the algorithm using a
    165   /// \ref concept::ReadMap "ReadMap", so it is easy to change it to any
     165  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
    166166  /// kind of capacity.
    167167  ///
    168168  /// The type of the capacity is determined by the \ref
    169   /// concept::ReadMap::Value "Value" of the capacity map.
     169  /// concepts::ReadMap::Value "Value" of the capacity map.
    170170  ///
    171171  /// It is also possible to change the underlying priority heap.
     
    180180  /// relatively time consuming process to compute the edge capacity if
    181181  /// it is necessary. The default map type is \ref
    182   /// concept::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
     182  /// concepts::Graph::EdgeMap "Graph::EdgeMap<int>".  The value
    183183  /// of CapacityMap is not used directly by search algorithm, it is only
    184184  /// passed to \ref MaxCardinalitySearchDefaultTraits. 
     
    715715    ///
    716716    /// The type of the map that stores the edge capacities.
    717     /// It must meet the \ref concept::ReadMap "ReadMap" concept.
     717    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    718718    typedef _CapacityMap CapacityMap;
    719719
  • lemon/prim.h

    r2230 r2260  
    3131#include <lemon/bits/traits.h>
    3232
    33 #include <lemon/concept/ugraph.h>
     33#include <lemon/concepts/ugraph.h>
    3434
    3535namespace lemon {
     
    4747
    4848    ///The type of the map that stores the edge costs.
    49     ///It must meet the \ref concept::ReadMap "ReadMap" concept.
     49    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
    5050    typedef CM CostMap;
    5151    //The type of the cost of the edges.
     
    8383    ///The type of the map that stores the last
    8484    ///edges of the minimum spanning tree.
    85     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     85    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    8686    ///
    8787    typedef typename UGraph::template NodeMap<typename GR::UEdge> PredMap;
     
    114114 
    115115    ///The type of the map that stores whether a nodes is processed.
    116     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     116    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    117117    ///By default it is a NodeMap<bool>.
    118118    typedef NullMap<typename UGraph::Node,bool> ProcessedMap;
     
    141141  ///
    142142  ///The edge costs are passed to the algorithm using a
    143   ///\ref concept::ReadMap "ReadMap",
     143  ///\ref concepts::ReadMap "ReadMap",
    144144  ///so it is easy to change it to any kind of cost.
    145145  ///
    146146  ///The type of the cost is determined by the
    147   ///\ref concept::ReadMap::Value "Value" of the cost map.
     147  ///\ref concepts::ReadMap::Value "Value" of the cost map.
    148148  ///
    149149  ///It is also possible to change the underlying priority heap.
     
    157157  ///relatively time consuming process to compute the edge cost if
    158158  ///it is necessary. The default map type is \ref
    159   ///concept::UGraph::UEdgeMap "UGraph::UEdgeMap<int>".  The value
     159  ///concepts::UGraph::UEdgeMap "UGraph::UEdgeMap<int>".  The value
    160160  ///of CM is not used directly by Prim, it is only passed to \ref
    161161  ///PrimDefaultTraits.
     
    413413      _heap(NULL), local_heap(false)
    414414    {
    415       checkConcept<concept::UGraph, UGraph>();
     415      checkConcept<concepts::UGraph, UGraph>();
    416416    }
    417417   
  • lemon/smart_graph.h

    r2256 r2260  
    195195  ///node and edge deletions</b>.
    196196  ///It conforms to
    197   ///the \ref concept::Graph "Graph concept" with an
     197  ///the \ref concepts::Graph "Graph concept" with an
    198198  ///important extra feature that
    199   ///its maps are real \ref concept::ReferenceMap "reference map"s.
    200   ///
    201   ///\sa concept::Graph.
     199  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
     200  ///
     201  ///\sa concepts::Graph.
    202202  ///
    203203  ///\author Alpar Juttner
     
    381381  /// node and edge deletions</b>.
    382382  /// Except from this it conforms to
    383   /// the \ref concept::UGraph "UGraph concept".
     383  /// the \ref concepts::UGraph "UGraph concept".
    384384  ///
    385385  ///It also has an
    386386  ///important extra feature that
    387   ///its maps are real \ref concept::ReferenceMap "reference map"s.
    388   ///
    389   /// \sa concept::UGraph.
     387  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
     388  ///
     389  /// \sa concepts::UGraph.
    390390  ///
    391391  /// \todo Snapshot hasn't been implemented yet.
     
    763763  /// that <b> it does not support node and edge deletions</b>.
    764764  /// Except from this it conforms to
    765   /// the \ref concept::BpUGraph "BpUGraph concept".
     765  /// the \ref concepts::BpUGraph "BpUGraph concept".
    766766  ///
    767767  ///It also has an
    768768  ///important extra feature that
    769   ///its maps are real \ref concept::ReferenceMap "reference map"s.
    770   ///
    771   /// \sa concept::BpUGraph.
     769  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
     770  ///
     771  /// \sa concepts::BpUGraph.
    772772  ///
    773773  class SmartBpUGraph : public ExtendedSmartBpUGraphBase {
  • lemon/topology.h

    r2111 r2260  
    2626#include <lemon/maps.h>
    2727
    28 #include <lemon/concept/graph.h>
    29 #include <lemon/concept/ugraph.h>
     28#include <lemon/concepts/graph.h>
     29#include <lemon/concepts/ugraph.h>
    3030#include <lemon/concept_check.h>
    3131
     
    5454  template <typename UGraph>
    5555  bool connected(const UGraph& graph) {
    56     checkConcept<concept::UGraph, UGraph>();
     56    checkConcept<concepts::UGraph, UGraph>();
    5757    typedef typename UGraph::NodeIt NodeIt;
    5858    if (NodeIt(graph) == INVALID) return true;
     
    7979  template <typename UGraph>
    8080  int countConnectedComponents(const UGraph &graph) {
    81     checkConcept<concept::UGraph, UGraph>();
     81    checkConcept<concepts::UGraph, UGraph>();
    8282    typedef typename UGraph::Node Node;
    8383    typedef typename UGraph::Edge Edge;
     
    127127  template <class UGraph, class NodeMap>
    128128  int connectedComponents(const UGraph &graph, NodeMap &compMap) {
    129     checkConcept<concept::UGraph, UGraph>();
     129    checkConcept<concepts::UGraph, UGraph>();
    130130    typedef typename UGraph::Node Node;
    131131    typedef typename UGraph::Edge Edge;
    132     checkConcept<concept::WriteMap<Node, int>, NodeMap>();
     132    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
    133133
    134134    typedef NullMap<Node, Edge> PredMap;
     
    245245  template <typename Graph>
    246246  bool stronglyConnected(const Graph& graph) {
    247     checkConcept<concept::Graph, Graph>();
     247    checkConcept<concepts::Graph, Graph>();
    248248
    249249    typedef typename Graph::Node Node;
     
    303303  template <typename Graph>
    304304  int countStronglyConnectedComponents(const Graph& graph) {
    305     checkConcept<concept::Graph, Graph>();
     305    checkConcept<concepts::Graph, Graph>();
    306306
    307307    using namespace _topology_bits;
     
    372372  template <typename Graph, typename NodeMap>
    373373  int stronglyConnectedComponents(const Graph& graph, NodeMap& compMap) {
    374     checkConcept<concept::Graph, Graph>();
     374    checkConcept<concepts::Graph, Graph>();
    375375    typedef typename Graph::Node Node;
    376376    typedef typename Graph::NodeIt NodeIt;
    377     checkConcept<concept::WriteMap<Node, int>, NodeMap>();
     377    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
    378378
    379379    using namespace _topology_bits;
     
    435435  template <typename Graph, typename EdgeMap>
    436436  int stronglyConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) {
    437     checkConcept<concept::Graph, Graph>();
     437    checkConcept<concepts::Graph, Graph>();
    438438    typedef typename Graph::Node Node;
    439439    typedef typename Graph::Edge Edge;
    440440    typedef typename Graph::NodeIt NodeIt;
    441     checkConcept<concept::WriteMap<Edge, bool>, EdgeMap>();
     441    checkConcept<concepts::WriteMap<Edge, bool>, EdgeMap>();
    442442
    443443    using namespace _topology_bits;
     
    731731  template <typename UGraph>
    732732  int countBiNodeConnectedComponents(const UGraph& graph) {
    733     checkConcept<concept::UGraph, UGraph>();
     733    checkConcept<concepts::UGraph, UGraph>();
    734734    typedef typename UGraph::NodeIt NodeIt;
    735735
     
    775775  int biNodeConnectedComponents(const UGraph& graph,
    776776                                UEdgeMap& compMap) {
    777     checkConcept<concept::UGraph, UGraph>();
     777    checkConcept<concepts::UGraph, UGraph>();
    778778    typedef typename UGraph::NodeIt NodeIt;
    779779    typedef typename UGraph::UEdge UEdge;
    780     checkConcept<concept::WriteMap<UEdge, int>, UEdgeMap>();
     780    checkConcept<concepts::WriteMap<UEdge, int>, UEdgeMap>();
    781781
    782782    using namespace _topology_bits;
     
    815815  template <typename UGraph, typename NodeMap>
    816816  int biNodeConnectedCutNodes(const UGraph& graph, NodeMap& cutMap) {
    817     checkConcept<concept::UGraph, UGraph>();
     817    checkConcept<concepts::UGraph, UGraph>();
    818818    typedef typename UGraph::Node Node;
    819819    typedef typename UGraph::NodeIt NodeIt;
    820     checkConcept<concept::WriteMap<Node, bool>, NodeMap>();
     820    checkConcept<concepts::WriteMap<Node, bool>, NodeMap>();
    821821
    822822    using namespace _topology_bits;
     
    10581058  template <typename UGraph>
    10591059  int countBiEdgeConnectedComponents(const UGraph& graph) {
    1060     checkConcept<concept::UGraph, UGraph>();
     1060    checkConcept<concepts::UGraph, UGraph>();
    10611061    typedef typename UGraph::NodeIt NodeIt;
    10621062
     
    11011101  template <typename UGraph, typename NodeMap>
    11021102  int biEdgeConnectedComponents(const UGraph& graph, NodeMap& compMap) {
    1103     checkConcept<concept::UGraph, UGraph>();
     1103    checkConcept<concepts::UGraph, UGraph>();
    11041104    typedef typename UGraph::NodeIt NodeIt;
    11051105    typedef typename UGraph::Node Node;
    1106     checkConcept<concept::WriteMap<Node, int>, NodeMap>();
     1106    checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
    11071107
    11081108    using namespace _topology_bits;
     
    11421142  template <typename UGraph, typename UEdgeMap>
    11431143  int biEdgeConnectedCutEdges(const UGraph& graph, UEdgeMap& cutMap) {
    1144     checkConcept<concept::UGraph, UGraph>();
     1144    checkConcept<concepts::UGraph, UGraph>();
    11451145    typedef typename UGraph::NodeIt NodeIt;
    11461146    typedef typename UGraph::UEdge UEdge;
    1147     checkConcept<concept::WriteMap<UEdge, bool>, UEdgeMap>();
     1147    checkConcept<concepts::WriteMap<UEdge, bool>, UEdgeMap>();
    11481148
    11491149    using namespace _topology_bits;
     
    12061206    using namespace _topology_bits;
    12071207
    1208     checkConcept<concept::Graph, Graph>();
    1209     checkConcept<concept::WriteMap<typename Graph::Node, int>, NodeMap>();
     1208    checkConcept<concepts::Graph, Graph>();
     1209    checkConcept<concepts::WriteMap<typename Graph::Node, int>, NodeMap>();
    12101210
    12111211    typedef typename Graph::Node Node;
     
    12481248    using namespace _topology_bits;
    12491249
    1250     checkConcept<concept::Graph, Graph>();
    1251     checkConcept<concept::ReadWriteMap<typename Graph::Node, int>, NodeMap>();
     1250    checkConcept<concepts::Graph, Graph>();
     1251    checkConcept<concepts::ReadWriteMap<typename Graph::Node, int>, NodeMap>();
    12521252
    12531253    typedef typename Graph::Node Node;
     
    12911291  bool dag(const Graph& graph) {
    12921292
    1293     checkConcept<concept::Graph, Graph>();
     1293    checkConcept<concepts::Graph, Graph>();
    12941294
    12951295    typedef typename Graph::Node Node;
     
    13321332  template <typename UGraph>
    13331333  bool acyclic(const UGraph& graph) {
    1334     checkConcept<concept::UGraph, UGraph>();
     1334    checkConcept<concepts::UGraph, UGraph>();
    13351335    typedef typename UGraph::Node Node;
    13361336    typedef typename UGraph::NodeIt NodeIt;
     
    13651365  template <typename UGraph>
    13661366  bool tree(const UGraph& graph) {
    1367     checkConcept<concept::UGraph, UGraph>();
     1367    checkConcept<concepts::UGraph, UGraph>();
    13681368    typedef typename UGraph::Node Node;
    13691369    typedef typename UGraph::NodeIt NodeIt;
     
    14031403  template<typename UGraph>
    14041404  inline bool bipartite(const UGraph &graph){
    1405     checkConcept<concept::UGraph, UGraph>();
     1405    checkConcept<concepts::UGraph, UGraph>();
    14061406   
    14071407    typedef typename UGraph::NodeIt NodeIt;
     
    14401440  template<typename UGraph, typename NodeMap>
    14411441  inline bool bipartitePartitions(const UGraph &graph, NodeMap &partMap){
    1442     checkConcept<concept::UGraph, UGraph>();
     1442    checkConcept<concepts::UGraph, UGraph>();
    14431443   
    14441444    typedef typename UGraph::Node Node;
  • lemon/vmap.h

    r1978 r2260  
    6060  };
    6161 
    62   ///Makes a virtual map from a \ref concept::ReadMap "ReadMap"
     62  ///Makes a virtual map from a \ref concepts::ReadMap "ReadMap"
    6363  template<class M, class K=typename M::Key,class V=typename M::Value>
    6464  class VReadMap : public VMapBase<K,V>
     
    7575  vReadMap(const M& m) {return VReadMap<M,K,V>(m);}
    7676
    77   ///Makes a virtual map from a \ref concept::WriteMap "WriteMap"
     77  ///Makes a virtual map from a \ref concepts::WriteMap "WriteMap"
    7878  template<class M, class K=typename M::Key,class V=typename M::Value>
    7979  class VWriteMap :public VMapBase<K,V>
     
    9090  vWriteMap(const M& m) {return VReadMap<M,K,V>(m);}
    9191
    92   ///Makes a virtual map from a \ref concept::ReadWriteMap "ReadWriteMap"
     92  ///Makes a virtual map from a \ref concepts::ReadWriteMap "ReadWriteMap"
    9393  template<class M, class K=typename M::Key,class V=typename M::Value>
    9494  class VReadWriteMap :public VMapBase<K,V>
  • test/bfs_test.cc

    r2247 r2260  
    2121#include <lemon/bfs.h>
    2222#include <lemon/path.h>
    23 #include<lemon/concept/graph.h>
     23#include<lemon/concepts/graph.h>
    2424
    2525using namespace lemon;
     
    3030void check_Bfs_Compile()
    3131{
    32   typedef concept::Graph Graph;
     32  typedef concepts::Graph Graph;
    3333
    3434  typedef Graph::Edge Edge;
     
    6767{
    6868  typedef int VType;
    69   typedef concept::Graph Graph;
     69  typedef concepts::Graph Graph;
    7070
    7171  typedef Graph::Edge Edge;
     
    7373  typedef Graph::EdgeIt EdgeIt;
    7474  typedef Graph::NodeIt NodeIt;
    75   typedef concept::ReadMap<Edge,VType> LengthMap;
     75  typedef concepts::ReadMap<Edge,VType> LengthMap;
    7676   
    7777  Graph g;
     
    7979  bfs(g).source(Node()).run();
    8080  bfs(g)
    81     .predMap(concept::WriteMap<Node,Edge>())
    82     .distMap(concept::WriteMap<Node,VType>())
    83     .reachedMap(concept::ReadWriteMap<Node,bool>())
    84     .processedMap(concept::WriteMap<Node,bool>())
     81    .predMap(concepts::WriteMap<Node,Edge>())
     82    .distMap(concepts::WriteMap<Node,VType>())
     83    .reachedMap(concepts::ReadWriteMap<Node,bool>())
     84    .processedMap(concepts::WriteMap<Node,bool>())
    8585    .run(Node());
    8686 
  • test/bpugraph_test.cc

    r2231 r2260  
    1717 */
    1818
    19 #include <lemon/concept/bpugraph.h>
     19#include <lemon/concepts/bpugraph.h>
    2020#include <lemon/list_graph.h>
    2121#include <lemon/smart_graph.h>
     
    2929
    3030using namespace lemon;
    31 using namespace lemon::concept;
     31using namespace lemon::concepts;
    3232
    3333void check_concepts() {
  • test/dfs_test.cc

    r2247 r2260  
    2121#include <lemon/dfs.h>
    2222#include <lemon/path.h>
    23 #include <lemon/concept/graph.h>
     23#include <lemon/concepts/graph.h>
    2424
    2525using namespace lemon;
     
    3030void check_Dfs_SmartGraph_Compile()
    3131{
    32   typedef concept::Graph Graph;
     32  typedef concepts::Graph Graph;
    3333
    3434  typedef Graph::Edge Edge;
     
    6868{
    6969  typedef int VType;
    70   typedef concept::Graph Graph;
     70  typedef concepts::Graph Graph;
    7171
    7272  typedef Graph::Edge Edge;
     
    7474  typedef Graph::EdgeIt EdgeIt;
    7575  typedef Graph::NodeIt NodeIt;
    76   typedef concept::ReadMap<Edge,VType> LengthMap;
     76  typedef concepts::ReadMap<Edge,VType> LengthMap;
    7777   
    7878  Graph g;
     
    8080  dfs(g).source(Node()).run();
    8181  dfs(g)
    82     .predMap(concept::WriteMap<Node,Edge>())
    83     .distMap(concept::WriteMap<Node,VType>())
    84     .reachedMap(concept::ReadWriteMap<Node,bool>())
    85     .processedMap(concept::WriteMap<Node,bool>())
     82    .predMap(concepts::WriteMap<Node,Edge>())
     83    .distMap(concepts::WriteMap<Node,VType>())
     84    .reachedMap(concepts::ReadWriteMap<Node,bool>())
     85    .processedMap(concepts::WriteMap<Node,bool>())
    8686    .run(Node());
    8787 
  • test/dijkstra_test.cc

    r2247 r2260  
    2222#include <lemon/path.h>
    2323#include <lemon/maps.h>
    24 #include <lemon/concept/graph.h>
    25 #include <lemon/concept/maps.h>
     24#include <lemon/concepts/graph.h>
     25#include <lemon/concepts/maps.h>
    2626using namespace lemon;
    2727
     
    3232{
    3333  typedef int VType;
    34   typedef concept::Graph Graph;
     34  typedef concepts::Graph Graph;
    3535
    3636  typedef Graph::Edge Edge;
     
    3838  typedef Graph::EdgeIt EdgeIt;
    3939  typedef Graph::NodeIt NodeIt;
    40   typedef concept::ReadMap<Edge,VType> LengthMap;
     40  typedef concepts::ReadMap<Edge,VType> LengthMap;
    4141 
    4242  typedef Dijkstra<Graph, LengthMap> DType;
     
    7171{
    7272  typedef int VType;
    73   typedef concept::Graph Graph;
     73  typedef concepts::Graph Graph;
    7474
    7575  typedef Graph::Edge Edge;
     
    7777  typedef Graph::EdgeIt EdgeIt;
    7878  typedef Graph::NodeIt NodeIt;
    79   typedef concept::ReadMap<Edge,VType> LengthMap;
     79  typedef concepts::ReadMap<Edge,VType> LengthMap;
    8080   
    8181  Graph g;
     
    8383  dijkstra(g,LengthMap()).source(Node()).run();
    8484  dijkstra(g,LengthMap())
    85     .predMap(concept::WriteMap<Node,Edge>())
    86     .distMap(concept::WriteMap<Node,VType>())
     85    .predMap(concepts::WriteMap<Node,Edge>())
     86    .distMap(concepts::WriteMap<Node,VType>())
    8787    .run(Node());
    8888 
  • test/edge_set_test.cc

    r2111 r2260  
    44#include <vector>
    55
    6 #include <lemon/concept/graph.h>
    7 #include <lemon/concept/ugraph.h>
     6#include <lemon/concepts/graph.h>
     7#include <lemon/concepts/ugraph.h>
    88#include <lemon/smart_graph.h>
    99
     
    1616
    1717using namespace lemon;
    18 using namespace lemon::concept;
     18using namespace lemon::concepts;
    1919
    2020typedef SmartGraph RGraph;
  • test/graph_adaptor_test.cc

    r2231 r2260  
    2121
    2222#include<lemon/smart_graph.h>
    23 #include<lemon/concept/graph.h>
    24 #include<lemon/concept/ugraph.h>
    25 #include<lemon/concept/bpugraph.h>
     23#include<lemon/concepts/graph.h>
     24#include<lemon/concepts/ugraph.h>
     25#include<lemon/concepts/bpugraph.h>
    2626
    2727#include<lemon/list_graph.h>
     
    4242
    4343using namespace lemon;
    44 using namespace lemon::concept;
     44using namespace lemon::concepts;
    4545
    4646
  • test/graph_factory_test.cc

    r2111 r2260  
    1919#include<iostream>
    2020#include<lemon/smart_graph.h>
    21 #include<lemon/concept/graph.h>
    22 #include<lemon/concept/maps.h>
     21#include<lemon/concepts/graph.h>
     22#include<lemon/concepts/maps.h>
    2323#include<lemon/list_graph_base.h>
    2424#include<lemon/full_graph.h>
     
    7171
    7272//Compile Graph
    73 template void lemon::concept::checkCompileGraph<concept::Graph>
    74 (concept::Graph &);
     73template void lemon::concepts::checkCompileGraph<concepts::Graph>
     74(concepts::Graph &);
    7575
    7676template
    77 void lemon::concept::checkCompileGraph<concept::Graph>
    78 (concept::Graph &);
     77void lemon::concepts::checkCompileGraph<concepts::Graph>
     78(concepts::Graph &);
    7979
    8080template
    81 void lemon::concept::checkCompileGraph<concept::Graph>
    82 (concept::Graph &);
     81void lemon::concepts::checkCompileGraph<concepts::Graph>
     82(concepts::Graph &);
    8383
    8484//Compile SmartGraph
    8585template
    86 void lemon::concept::checkCompileGraph<SmartGraph>(SmartGraph &);
     86void lemon::concepts::checkCompileGraph<SmartGraph>(SmartGraph &);
    8787template
    88 void lemon::concept::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
     88void lemon::concepts::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
    8989
    9090//Compile SymSmartGraph
     
    9494//Compile ListGraph
    9595template
    96 void lemon::concept::checkCompileGraph<ListGraph>(ListGraph &);
     96void lemon::concepts::checkCompileGraph<ListGraph>(ListGraph &);
    9797template
    98 void lemon::concept::checkCompileGraph<ListGraph>(ListGraph &);
     98void lemon::concepts::checkCompileGraph<ListGraph>(ListGraph &);
    9999template
    100 void lemon::concept::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
     100void lemon::concepts::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
    101101
    102102
     
    107107
    108108//Compile FullGraph
    109 template void lemon::concept::checkCompileGraph<FullGraph>(FullGraph &);
     109template void lemon::concepts::checkCompileGraph<FullGraph>(FullGraph &);
    110110template
    111 void lemon::concept::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
     111void lemon::concepts::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
    112112
    113113
     
    144144  // Some map tests.
    145145  // FIXME: These shouldn't be here.
    146   using namespace concept;
     146  using namespace concepts;
    147147  function_requires< ReadMapConcept< ReadMap<int,int> > >();
    148148  function_requires< WriteMapConcept< WriteMap<int,int> > >();
  • test/graph_test.cc

    r2231 r2260  
    2020#include <vector>
    2121
    22 #include <lemon/concept/graph.h>
     22#include <lemon/concepts/graph.h>
    2323#include <lemon/list_graph.h>
    2424#include <lemon/smart_graph.h>
     
    3232
    3333using namespace lemon;
    34 using namespace lemon::concept;
     34using namespace lemon::concepts;
    3535
    3636
  • test/heap_test.cc

    r2108 r2260  
    2323
    2424#include <lemon/concept_check.h>
    25 #include <lemon/concept/heap.h>
     25#include <lemon/concepts/heap.h>
    2626
    2727#include <lemon/smart_graph.h>
     
    4141
    4242using namespace lemon;
    43 using namespace lemon::concept;
     43using namespace lemon::concepts;
    4444
    4545
  • test/kruskal_test.cc

    r2135 r2260  
    2424#include <lemon/kruskal.h>
    2525#include <lemon/list_graph.h>
    26 #include <lemon/concept/maps.h>
    27 #include <lemon/concept/graph.h>
     26#include <lemon/concepts/maps.h>
     27#include <lemon/concepts/graph.h>
    2828
    2929
     
    3333void checkCompileKruskal()
    3434{
    35   concept::WriteMap<concept::Graph::Edge,bool> w;
     35  concepts::WriteMap<concepts::Graph::Edge,bool> w;
    3636
    37   concept::Graph g;
     37  concepts::Graph g;
    3838  kruskal(g,
    39           concept::ReadMap<concept::Graph::Edge,int>(),
     39          concepts::ReadMap<concepts::Graph::Edge,int>(),
    4040          w);
    4141}
  • test/maps_test.cc

    r2032 r2260  
    2121
    2222#include <lemon/concept_check.h>
    23 #include <lemon/concept/maps.h>
     23#include <lemon/concepts/maps.h>
    2424#include <lemon/maps.h>
    2525
     
    2727
    2828using namespace lemon;
    29 using namespace lemon::concept;
     29using namespace lemon::concepts;
    3030
    3131struct A {};
  • test/matrix_maps_test.cc

    r2242 r2260  
    2222#include <lemon/concept_check.h>
    2323
    24 #include <lemon/concept/matrix_maps.h>
    25 #include <lemon/concept/maps.h>
    26 #include <lemon/concept/graph.h>
     24#include <lemon/concepts/matrix_maps.h>
     25#include <lemon/concepts/maps.h>
     26#include <lemon/concepts/graph.h>
    2727
    2828#include <lemon/matrix_maps.h>
     
    3636
    3737using namespace lemon;
    38 using namespace lemon::concept;
     38using namespace lemon::concepts;
    3939
    4040int main() {
  • test/path_test.cc

    r2247 r2260  
    2020#include <iostream>
    2121
    22 #include <lemon/concept/path.h>
    23 #include <lemon/concept/graph.h>
     22#include <lemon/concepts/path.h>
     23#include <lemon/concepts/graph.h>
    2424
    2525#include <lemon/path.h>
     
    3232
    3333void check_concepts() {
    34   checkConcept<concept::Path<concept::Graph>,
    35     concept::Path<concept::Graph> >();
    36   checkConcept<concept::Path<concept::Graph>,
    37     Path<concept::Graph> >();
    38   checkConcept<concept::Path<ListGraph>, Path<ListGraph> >();
     34  checkConcept<concepts::Path<concepts::Graph>,
     35    concepts::Path<concepts::Graph> >();
     36  checkConcept<concepts::Path<concepts::Graph>,
     37    Path<concepts::Graph> >();
     38  checkConcept<concepts::Path<ListGraph>, Path<ListGraph> >();
    3939}
    4040
  • test/preflow_test.cc

    r2111 r2260  
    2424#include <lemon/dimacs.h>
    2525#include <lemon/preflow.h>
    26 #include <lemon/concept/graph.h>
    27 #include <lemon/concept/maps.h>
     26#include <lemon/concepts/graph.h>
     27#include <lemon/concepts/maps.h>
    2828
    2929using namespace lemon;
     
    3232{
    3333  typedef int VType;
    34   typedef concept::Graph Graph;
     34  typedef concepts::Graph Graph;
    3535
    3636  typedef Graph::Node Node;
    3737  typedef Graph::Edge Edge;
    38   typedef concept::ReadMap<Edge,VType> CapMap;
    39   typedef concept::ReadWriteMap<Edge,VType> FlowMap;
    40   typedef concept::ReadWriteMap<Node,bool> CutMap;
     38  typedef concepts::ReadMap<Edge,VType> CapMap;
     39  typedef concepts::ReadWriteMap<Edge,VType> FlowMap;
     40  typedef concepts::ReadWriteMap<Node,bool> CutMap;
    4141 
    4242  typedef Preflow<Graph, int, CapMap, FlowMap> PType;
  • test/test_tools.h

    r2242 r2260  
    2727
    2828#include <lemon/concept_check.h>
    29 #include <lemon/concept/graph.h>
     29#include <lemon/concepts/graph.h>
    3030
    3131#include <lemon/random.h>
  • test/ugraph_test.cc

    r2231 r2260  
    1818
    1919#include <lemon/bits/graph_extender.h>
    20 #include <lemon/concept/ugraph.h>
     20#include <lemon/concepts/ugraph.h>
    2121#include <lemon/list_graph.h>
    2222#include <lemon/smart_graph.h>
     
    3030
    3131using namespace lemon;
    32 using namespace lemon::concept;
     32using namespace lemon::concepts;
    3333
    3434void check_concepts() {
Note: See TracChangeset for help on using the changeset viewer.