COIN-OR::LEMON - Graph Library

Changeset 959:c80ef5912903 in lemon-0.x


Ignore:
Timestamp:
11/04/04 21:24:59 (15 years ago)
Author:
Mihaly Barasz
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1342
Message:

skeleton(s) -> concept renaming

Files:
5 added
5 deleted
30 edited

Legend:

Unmodified
Added
Removed
  • doc/Doxyfile

    r953 r959  
    432432                         namespaces.dox \
    433433                         ../src/lemon \
    434                          ../src/lemon/skeletons \
     434                         ../src/lemon/concept \
    435435                         ../src/test/test_tools.h
    436436
  • doc/graphs.dox

    r921 r959  
    1010
    1111Each graph should meet the
    12 \ref lemon::skeleton::StaticGraph "StaticGraph" concept.
     12\ref lemon::concept::StaticGraph "StaticGraph" concept.
    1313This concept does not
    1414makes it possible to change the graph (i.e. it is not possible to add
     
    1717
    1818The graphs meeting the
    19 \ref lemon::skeleton::ExtendableGraph "ExtendableGraph"
     19\ref lemon::concept::ExtendableGraph "ExtendableGraph"
    2020concept allow node and
    2121edge addition. You can also "clear" (i.e. erase all edges and nodes)
     
    2323
    2424In case of graphs meeting the full feature
    25 \ref lemon::skeleton::ErasableGraph "ErasableGraph"
     25\ref lemon::concept::ErasableGraph "ErasableGraph"
    2626concept
    2727you can also erase individual edges and node in arbitrary order.
     
    2929The implemented graph structures are the following.
    3030\li \ref lemon::ListGraph "ListGraph" is the most versatile graph class. It meets
    31 the \ref lemon::skeleton::ErasableGraph "ErasableGraph" concept
     31the \ref lemon::concept::ErasableGraph "ErasableGraph" concept
    3232and it also have some convenience features.
    3333\li \ref lemon::SmartGraph "SmartGraph" is a more memory
    3434efficient version of \ref lemon::ListGraph "ListGraph". The
    3535price of it is that it only meets the
    36 \ref lemon::skeleton::ExtendableGraph "ExtendableGraph" concept,
     36\ref lemon::concept::ExtendableGraph "ExtendableGraph" concept,
    3737so you cannot delete individual edges or nodes.
    3838\li \ref lemon::SymListGraph "SymListGraph" and
     
    4646are shared by the edge pairs.
    4747\li \ref lemon::FullGraph "FullGraph"
    48 implements a full graph. It is a \ref lemon::skeleton::StaticGraph, so you cannot
     48implements a full graph. It is a \ref lemon::concept::StaticGraph, so you cannot
    4949change the number of nodes once it is constructed. It is extremely memory
    5050efficient: it uses constant amount of memory independently from the number of
  • doc/groups.dox

    r947 r959  
    8181
    8282/**
    83 @defgroup skeletons Skeletons
    84 \brief Skeletons (a.k.a. concept checking classes)
     83@defgroup concept Concept
     84\brief Skeleton classes and concept checking classes
    8585
    86 This group describes the data/algorithm skeletons implemented in LEMON in
    87 order to make it easier to check if a certain template class or
    88 template function is correctly implemented.
     86This group describes the data/algorithm skeletons and concept checking
     87classes implemented in LEMON. These classes exist in order to make it
     88easier to check if a certain template class or template function is
     89correctly implemented.
    8990*/
    9091
  • doc/namespaces.dox

    r921 r959  
    99  /// \todo Some more detailed description would be nice here.
    1010  ///
    11   namespace skeleton {}
     11  namespace concept {}
    1212}
  • src/lemon/Makefile.am

    r946 r959  
    3737
    3838noinst_HEADERS =                                                        \
    39         skeletons/graph.h                                               \
    40         skeletons/graph_component.h                                     \
    41         skeletons/sym_graph.h                                           \
    42         skeletons/maps.h                                                \
    43         skeletons/path.h
     39        concept/graph.h                                                 \
     40        concept/graph_component.h                                       \
     41        concept/sym_graph.h                                             \
     42        concept/maps.h                                                  \
     43        concept/path.h
  • src/lemon/dijkstra.h

    r921 r959  
    3434  ///This class provides an efficient implementation of %Dijkstra algorithm.
    3535  ///The edge lengths are passed to the algorithm using a
    36   ///\ref skeleton::ReadMap "ReadMap",
     36  ///\ref concept::ReadMap "ReadMap",
    3737  ///so it is easy to change it to any kind of length.
    3838  ///
    3939  ///The type of the length is determined by the
    40   ///\ref skeleton::ReadMap::ValueType "ValueType" of the length map.
     40  ///\ref concept::ReadMap::ValueType "ValueType" of the length map.
    4141  ///
    4242  ///It is also possible to change the underlying priority heap.
     
    4949  ///may involve in relatively time consuming process to compute the edge
    5050  ///length if it is necessary. The default map type is
    51   ///\ref skeleton::StaticGraph::EdgeMap "Graph::EdgeMap<int>"
     51  ///\ref concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>"
    5252  ///\param Heap The heap type used by the %Dijkstra
    5353  ///algorithm. The default
  • src/lemon/full_graph.h

    r951 r959  
    195195  ///edges or nodes.
    196196  ///Thus it conforms to
    197   ///the \ref skeleton::StaticGraph "StaticGraph" concept
    198   ///\sa skeleton::StaticGraph.
     197  ///the \ref concept::StaticGraph "StaticGraph" concept
     198  ///\sa concept::StaticGraph.
    199199  ///\todo What about loops?
    200200  ///\todo Don't we need SymEdgeMap?
  • src/lemon/list_graph.h

    r949 r959  
    318318  ///
    319319  ///It conforms to the
    320   ///\ref skeleton::ErasableGraph "ErasableGraph" concept.
    321   ///\sa skeleton::ErasableGraph.
     320  ///\ref concept::ErasableGraph "ErasableGraph" concept.
     321  ///\sa concept::ErasableGraph.
    322322
    323323  class ListGraph : public ErasableListGraphBase
  • src/lemon/maps.h

    r921 r959  
    2121///\brief Miscellaneous property maps
    2222///
    23 ///\todo This file has the same name as the concept file in skeletons,
     23///\todo This file has the same name as the concept file in concept/,
    2424/// and this is not easily detectable in docs...
    2525
  • src/lemon/path.h

    r921 r959  
    2727algorithm to store its result in any kind of path structure.
    2828
    29 \sa lemon::skeleton::Path
     29\sa lemon::concept::Path
    3030
    3131*/
  • src/lemon/smart_graph.h

    r950 r959  
    230230  ///that <b> it does not support node and edge deletion</b>.
    231231  ///It conforms to
    232   ///the \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
    233   ///\sa skeleton::ExtendableGraph.
     232  ///the \ref concept::ExtendableGraph "ExtendableGraph" concept.
     233  ///\sa concept::ExtendableGraph.
    234234  ///
    235235  ///\todo Some member functions could be \c static.
  • src/test/bfs_test.cc

    r921 r959  
    1818#include <lemon/smart_graph.h>
    1919#include <lemon/bfs.h>
    20 #include<lemon/skeletons/graph.h>
     20#include<lemon/concept/graph.h>
    2121
    2222using namespace lemon;
     
    2727void check_Bfs_Compile()
    2828{
    29   typedef skeleton::StaticGraph Graph;
     29  typedef concept::StaticGraph Graph;
    3030
    3131  typedef Graph::Edge Edge;
  • src/test/dfs_test.cc

    r921 r959  
    1818#include <lemon/smart_graph.h>
    1919#include <lemon/dfs.h>
    20 #include<lemon/skeletons/graph.h>
     20#include <lemon/concept/graph.h>
    2121
    2222using namespace lemon;
     
    2727void check_Dfs_SmartGraph_Compile()
    2828{
    29   typedef skeleton::StaticGraph Graph;
     29  typedef concept::StaticGraph Graph;
    3030
    3131  typedef Graph::Edge Edge;
  • src/test/dijkstra_test.cc

    r921 r959  
    1818#include <lemon/smart_graph.h>
    1919#include <lemon/dijkstra.h>
    20 #include<lemon/skeletons/graph.h>
    21 #include<lemon/skeletons/maps.h>
     20#include <lemon/concept/graph.h>
     21#include <lemon/concept/maps.h>
    2222using namespace lemon;
    2323
     
    2828{
    2929  typedef int VType;
    30   typedef skeleton::StaticGraph Graph;
     30  typedef concept::StaticGraph Graph;
    3131
    3232  typedef Graph::Edge Edge;
     
    3434  typedef Graph::EdgeIt EdgeIt;
    3535  typedef Graph::NodeIt NodeIt;
    36   typedef skeleton::ReadMap<Edge,VType> LengthMap;
     36  typedef concept::ReadMap<Edge,VType> LengthMap;
    3737 
    3838  typedef Dijkstra<Graph, LengthMap> DType;
  • src/test/graph_factory_test.cc

    r946 r959  
    1717#include<iostream>
    1818#include<lemon/smart_graph.h>
    19 #include<lemon/skeletons/graph.h>
    20 #include<lemon/skeletons/maps.h>
     19#include<lemon/concept/graph.h>
     20#include<lemon/concept/maps.h>
    2121#include<lemon/list_graph_base.h>
    2222#include<lemon/full_graph.h>
     
    6969
    7070//Compile Graph
    71 template void lemon::skeleton::checkCompileStaticGraph<skeleton::StaticGraph>
    72 (skeleton::StaticGraph &);
     71template void lemon::concept::checkCompileStaticGraph<concept::StaticGraph>
     72(concept::StaticGraph &);
    7373
    7474template
    75 void lemon::skeleton::checkCompileExtendableGraph<skeleton::ExtendableGraph>
    76 (skeleton::ExtendableGraph &);
     75void lemon::concept::checkCompileExtendableGraph<concept::ExtendableGraph>
     76(concept::ExtendableGraph &);
    7777
    7878template
    79 void lemon::skeleton::checkCompileErasableGraph<skeleton::ErasableGraph>
    80 (skeleton::ErasableGraph &);
     79void lemon::concept::checkCompileErasableGraph<concept::ErasableGraph>
     80(concept::ErasableGraph &);
    8181
    8282//Compile SmartGraph
    8383template
    84 void lemon::skeleton::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);
     84void lemon::concept::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);
    8585template
    86 void lemon::skeleton::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
     86void lemon::concept::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
    8787
    8888//Compile SymSmartGraph
     
    9292//Compile ListGraph
    9393template
    94 void lemon::skeleton::checkCompileExtendableGraph<ListGraph>(ListGraph &);
     94void lemon::concept::checkCompileExtendableGraph<ListGraph>(ListGraph &);
    9595template
    96 void lemon::skeleton::checkCompileErasableGraph<ListGraph>(ListGraph &);
     96void lemon::concept::checkCompileErasableGraph<ListGraph>(ListGraph &);
    9797template
    98 void lemon::skeleton::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
     98void lemon::concept::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
    9999
    100100
     
    105105
    106106//Compile FullGraph
    107 template void lemon::skeleton::checkCompileStaticGraph<FullGraph>(FullGraph &);
     107template void lemon::concept::checkCompileStaticGraph<FullGraph>(FullGraph &);
    108108template
    109 void lemon::skeleton::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
     109void lemon::concept::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
    110110
    111111
     
    142142  // Some map tests.
    143143  // FIXME: These shouldn't be here.
    144   using namespace skeleton;
     144  using namespace concept;
    145145  function_requires< ReadMapConcept< ReadMap<int,int> > >();
    146146  function_requires< WriteMapConcept< WriteMap<int,int> > >();
  • src/test/graph_test.cc

    r946 r959  
    44#include <vector>
    55
    6 #include <lemon/skeletons/graph.h>
     6#include <lemon/concept/graph.h>
    77#include <lemon/list_graph.h>
    88#include <lemon/smart_graph.h>
     
    1515
    1616using namespace lemon;
    17 using namespace lemon::skeleton;
     17using namespace lemon::concept;
    1818
    1919
  • src/test/graph_wrapper_test.cc

    r946 r959  
    1919
    2020#include<lemon/smart_graph.h>
    21 #include<lemon/skeletons/graph.h>
     21#include<lemon/concept/graph.h>
    2222
    2323#include<lemon/list_graph.h>
     
    3636
    3737using namespace lemon;
    38 using namespace lemon::skeleton;
     38using namespace lemon::concept;
    3939
    4040
  • src/test/kruskal_test.cc

    r921 r959  
    2222#include <lemon/kruskal.h>
    2323#include <lemon/list_graph.h>
    24 #include <lemon/skeletons/maps.h>
    25 #include <lemon/skeletons/graph.h>
     24#include <lemon/concept/maps.h>
     25#include <lemon/concept/graph.h>
    2626
    2727
     
    3131void checkCompileKruskal()
    3232{
    33   skeleton::WriteMap<skeleton::StaticGraph::Edge,bool> w;
     33  concept::WriteMap<concept::StaticGraph::Edge,bool> w;
    3434
    35   kruskalEdgeMap(skeleton::StaticGraph(),
    36                  skeleton::ReadMap<skeleton::StaticGraph::Edge,int>(),
     35  kruskalEdgeMap(concept::StaticGraph(),
     36                 concept::ReadMap<concept::StaticGraph::Edge,int>(),
    3737                 w);
    3838}
  • src/test/new_graph_test.cc

    r946 r959  
    1515 */
    1616
    17 #include <lemon/skeletons/graph.h>
     17#include <lemon/concept/graph.h>
    1818// #include <boost/concept_check.hpp>
    1919
    20 using namespace lemon::skeleton;
     20using namespace lemon::concept;
    2121
    2222// Borrowed from boost:
  • src/test/path_test.cc

    r921 r959  
    1717#include <string>
    1818#include <iostream>
    19 #include <lemon/skeletons/path.h>
     19#include <lemon/concept/path.h>
    2020#include <lemon/path.h>
    2121#include <lemon/list_graph.h>
     
    2323using namespace std;
    2424using namespace lemon;
    25 using namespace skeleton;
     25using namespace lemon::concept;
    2626
    2727template<class Path> void checkCompilePath(Path &P)
     
    8787}
    8888
    89 template void checkCompilePath< skeleton::Path<ListGraph> >(skeleton::Path<ListGraph> &);
     89template void checkCompilePath< concept::Path<ListGraph> >(concept::Path<ListGraph> &);
    9090template void checkCompilePath< DirPath<ListGraph> >(DirPath<ListGraph> &);
    9191template void checkCompilePath< UndirPath<ListGraph> >(UndirPath<ListGraph> &);
  • src/test/preflow_test.cc

    r940 r959  
    2222#include <lemon/dimacs.h>
    2323#include <lemon/preflow.h>
    24 #include <lemon/skeletons/graph.h>
    25 #include <lemon/skeletons/maps.h>
     24#include <lemon/concept/graph.h>
     25#include <lemon/concept/maps.h>
    2626
    2727using namespace lemon;
     
    3030{
    3131  typedef int VType;
    32   typedef skeleton::StaticGraph Graph;
     32  typedef concept::StaticGraph Graph;
    3333
    3434  typedef Graph::Node Node;
    3535  typedef Graph::Edge Edge;
    36   typedef skeleton::ReadMap<Edge,VType> CapMap;
    37   typedef skeleton::ReadWriteMap<Edge,VType> FlowMap;
    38   typedef skeleton::ReadWriteMap<Node,bool> CutMap;
     36  typedef concept::ReadMap<Edge,VType> CapMap;
     37  typedef concept::ReadWriteMap<Edge,VType> FlowMap;
     38  typedef concept::ReadWriteMap<Node,bool> CutMap;
    3939 
    4040  typedef Preflow<Graph, int, CapMap, FlowMap> PType;
  • src/test/sym_graph_test.cc

    r938 r959  
    1717#include<iostream>
    1818
    19 #include<lemon/skeletons/sym_graph.h>
     19#include<lemon/concept/sym_graph.h>
    2020
    2121#include<lemon/list_graph.h>
     
    5555
    5656//Compile Graph
    57 template void lemon::checkCompileStaticSymGraph<skeleton::StaticSymGraph>
    58 (skeleton::StaticSymGraph &);
     57template void lemon::checkCompileStaticSymGraph<concept::StaticSymGraph>
     58(concept::StaticSymGraph &);
    5959
    60 template void lemon::checkCompileSymGraph<skeleton::ExtendableSymGraph>
    61 (skeleton::ExtendableSymGraph &);
     60template void lemon::checkCompileSymGraph<concept::ExtendableSymGraph>
     61(concept::ExtendableSymGraph &);
    6262
    63 template void lemon::checkCompileErasableSymGraph<skeleton::ErasableSymGraph>
    64 (skeleton::ErasableSymGraph &);
     63template void lemon::checkCompileErasableSymGraph<concept::ErasableSymGraph>
     64(concept::ErasableSymGraph &);
    6565
    6666
     
    6868template void lemon::checkCompileSymGraph<SymSmartGraph>(SymSmartGraph &);
    6969template
    70 void lemon::skeleton::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
     70void lemon::concept::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
    7171
    7272//Compile SymListGraph
     
    7474template void lemon::checkCompileErasableSymGraph<SymListGraph>(SymListGraph &);
    7575template
    76 void lemon::skeleton::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
     76void lemon::concept::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
    7777
    7878int main()
  • src/test/sym_graph_test.h

    r938 r959  
    2828  /// \e
    2929
    30   /// \todo This should go to lemon/skeleton/symgraph.h
     30  /// \todo This should go to lemon/concept/symgraph.h
    3131  ///
    3232  template<class Graph> void checkCompileStaticSymGraph(Graph &G)
     
    4141      typedef typename Graph::OutEdgeIt OutEdgeIt;
    4242
    43       lemon::skeleton::checkCompileStaticGraph(G);
     43      lemon::concept::checkCompileStaticGraph(G);
    4444 
    4545      {
     
    158158    {
    159159      checkCompileSymGraph(G);
    160       lemon::skeleton::checkCompileGraphEraseNode(G);
     160      lemon::concept::checkCompileGraphEraseNode(G);
    161161      checkCompileSymGraphEraseSymEdge(G);
    162162    }
  • src/work/Doxyfile

    r939 r959  
    397397                         ../../doc/groups.dox \
    398398                         ../lemon \
    399                          ../lemon/skeletons \
     399                         ../lemon/concept \
    400400                         ../test/test_tools.h \
    401401                         klao/path.h \
  • src/work/alpar/dijkstra.h

    r955 r959  
    101101  ///This class provides an efficient implementation of %Dijkstra algorithm.
    102102  ///The edge lengths are passed to the algorithm using a
    103   ///\ref skeleton::ReadMap "ReadMap",
     103  ///\ref concept::ReadMap "ReadMap",
    104104  ///so it is easy to change it to any kind of length.
    105105  ///
    106106  ///The type of the length is determined by the
    107   ///\ref skeleton::ReadMap::ValueType "ValueType" of the length map.
     107  ///\ref concept::ReadMap::ValueType "ValueType" of the length map.
    108108  ///
    109109  ///It is also possible to change the underlying priority heap.
     
    118118  ///may involve in relatively time consuming process to compute the edge
    119119  ///length if it is necessary. The default map type is
    120   ///\ref skeleton::StaticGraph::EdgeMap "Graph::EdgeMap<int>".
     120  ///\ref concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>".
    121121  ///The value of LM is not used directly by Dijkstra, it
    122122  ///is only passed to \ref DijkstraDefaultTraits.
  • src/work/alpar/list_graph_demo.cc

    r921 r959  
    11#include<list_graph.h>
    2 #include<skeletons/graph.h>
     2#include<concept/graph.h>
    33
    44#include <iostream>
  • src/work/marci/bfs_mm_test.cc

    r944 r959  
    1818#include <lemon/smart_graph.h>
    1919#include <bfs_mm.h>
    20 #include <lemon/skeletons/graph.h>
     20#include <lemon/concept/graph.h>
    2121
    2222using namespace lemon;
     
    2727void check_Bfs_Compile()
    2828{
    29   typedef skeleton::StaticGraph Graph;
     29  typedef concept::StaticGraph Graph;
    3030
    3131  typedef Graph::Edge Edge;
  • src/work/peter/path/path.h

    r921 r959  
    1313algorithm to store its result in any kind of path structure.
    1414
    15 \sa lemon::skeleton::Path
     15\sa lemon::concept::Path
    1616
    1717*/
  • src/work/peter/path/path_skeleton.h

    r921 r959  
    22// -*- c++ -*- //
    33
    4 ///\ingroup skeletons
     4///\ingroup concept
    55///\file
    66///\brief Classes for representing paths in graphs.
     
    1212
    1313namespace lemon {
    14   namespace skeleton {
    15     /// \addtogroup skeletons
     14  namespace concept {
     15    /// \addtogroup concept
    1616    /// @{
    1717   
    1818   
    19     //! \brief A skeletom structure for representing directed paths in a graph.
     19    //! \brief A skeleton structure for representing directed paths in a graph.
    2020    //!
    2121    //! A skeleton structure for representing directed paths in a graph.
     
    8686       * \brief Iterator class to iterate on the edges of the paths
    8787       *
    88        * \ingroup skeletons
     88       * \ingroup concept
    8989       * This class is used to iterate on the edges of the paths
    9090       *
     
    119119       * \brief Iterator class to iterate on the nodes of the paths
    120120       *
    121        * \ingroup skeletons
     121       * \ingroup concept
    122122       * This class is used to iterate on the nodes of the paths
    123123       *
     
    154154       * \brief Class to build paths
    155155       *
    156        * \ingroup skeletons
     156       * \ingroup concept
    157157       * This class is used to fill a path with edges.
    158158       *
  • src/work/peter/path/path_test.cc

    r921 r959  
    77using namespace std;
    88using namespace lemon;
    9 using namespace skeleton;
     9using namespace concept;
    1010
    1111bool passed = true;
Note: See TracChangeset for help on using the changeset viewer.