COIN-OR::LEMON - Graph Library

Changeset 2260:4274224f8a7d in lemon-0.x for lemon


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)

Location:
lemon
Files:
8 added
8 deleted
34 edited

Legend:

Unmodified
Added
Removed
  • 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>
Note: See TracChangeset for help on using the changeset viewer.