COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

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


Ignore:
Timestamp:
10/24/06 19:19:16 (17 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3016
Message:

concept -> concepts (namespace & directory)

Location:
test
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • 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.