COIN-OR::LEMON - Graph Library

Changeset 880:9d0bfd35b97c in lemon-0.x


Ignore:
Timestamp:
09/17/04 17:51:50 (15 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1188
Message:
  • Name changing: XYZGraphSkeleton -> XYZGraph
  • Fix some bad \ref's in the doc.
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • doc/graphs.dox

    r875 r880  
    1010
    1111Each graph should meet the
    12 \ref hugo::skeleton::StaticGraphSkeleton "StaticGraph" concept.
     12\ref hugo::skeleton::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 hugo::skeleton::ExtendableGraphSkeleton "ExtendableGraph"
     19\ref hugo::skeleton::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 hugo::skeleton::ErasableGraphSkeleton "ErasableGraph"
     25\ref hugo::skeleton::ErasableGraph "ErasableGraph"
    2626concept
    2727you can also erase individual edges and node in arbitrary order.
     
    2929The implemented graph structures are the following.
    3030\li \ref hugo::ListGraph "ListGraph" is the most versatile graph class. It meets
    31 the hugo::skeleton::ErasableGraphSkeleton "ErasableGraph" concept
     31the hugo::skeleton::ErasableGraph "ErasableGraph" concept
    3232and it also have some convenience features.
    3333\li \ref hugo::SmartGraph "SmartGraph" is a more memory
    3434efficient version of \ref hugo::ListGraph "ListGraph". The
    3535price of it is that it only meets the
    36 \ref hugo::skeleton::ExtendableGraphSkeleton "ExtendableGraph" concept,
     36\ref hugo::skeleton::ExtendableGraph "ExtendableGraph" concept,
    3737so you cannot delete individual edges or nodes.
    3838\li \ref hugo::SymListGraph "SymListGraph" and
  • src/hugo/dijkstra.h

    r802 r880  
    1919  ///This class provides an efficient implementation of %Dijkstra algorithm.
    2020  ///The edge lengths are passed to the algorithm using a
    21   ///\ref ReadMapSkeleton "readable map",
     21  ///\ref skeleton::ReadMap "ReadMap",
    2222  ///so it is easy to change it to any kind of length.
    2323  ///
    24   ///The type of the length is determined by the \c ValueType of the length map.
     24  ///The type of the length is determined by the
     25  ///\ref skeleton::ReadMap::ValueType "ValueType" of the length map.
    2526  ///
    2627  ///It is also possible to change the underlying priority heap.
     
    3334  ///may involve in relatively time consuming process to compute the edge
    3435  ///length if it is necessary. The default map type is
    35   ///\ref GraphSkeleton::EdgeMap "Graph::EdgeMap<int>"
     36  ///\ref skeleton::StaticGraph::EdgeMap "Graph::EdgeMap<int>"
    3637  ///\param Heap The heap type used by the %Dijkstra
    3738  ///algorithm. The default
  • src/hugo/full_graph.h

    r822 r880  
    2828  ///It is completely static, so you can neither add nor delete either
    2929  ///edges or nodes.
    30   ///Otherwise it conforms to the graph interface documented under
    31   ///the description of \ref GraphSkeleton.
    32   ///\sa \ref GraphSkeleton.
     30  ///Thus it conforms to
     31  ///the \ref skeleton::StaticGraph "StaticGraph" concept
     32  ///\sa skeleton::StaticGraph.
    3333  ///\todo What about loops?
    3434  ///\todo Don't we need SymEdgeMap?
  • src/hugo/list_graph.h

    r877 r880  
    3030  ///This is a simple and fast erasable graph implementation.
    3131  ///
    32   ///It conforms to the graph interface documented under
    33   ///the description of
    34   ///\ref skeleton::ErasableGraphSkeleton "ErasableGraphSkeleton".
    35   ///\sa skeleton::ErasableGraphSkeleton.
     32  ///It conforms to the
     33  ///\ref skeleton::ErasableGraph "ErasableGraph" concept.
     34  ///\sa skeleton::ErasableGraph.
    3635  class ListGraph {
    3736
     
    313312      NodeIt(Invalid i) : Node(i) { }
    314313      NodeIt(const ListGraph& _G) : Node(_G.first_node), G(&_G) { }
    315       ///\todo Undocumented conversion Node -\> NodeIt.
    316314      NodeIt(const ListGraph& _G,Node n) : Node(n), G(&_G) { }
    317315      NodeIt &operator++() {
     
    427425  ///feature by
    428426  ///storing shared values for the edge pairs. The usual
    429   ///\ref GraphSkeleton::EdgeMap "EdgeMap"
     427  ///\ref Graph::EdgeMap "EdgeMap"
    430428  ///can be used
    431429  ///as well.
     
    495493  ///\ref EdgeSet class.
    496494  ///
    497   ///It conforms to the graph interface documented under
    498   ///the description of \ref GraphSkeleton with the exception that you cannot
     495  ///It conforms to
     496  ///the \ref skeleton::ExtendableGraph "ExtendableGraph" concept
     497  ///with the exception that you cannot
    499498  ///add (or delete) edges. The usual edge iterators are exists, but they are
    500499  ///always \ref INVALID.
    501   ///\sa \ref GraphSkeleton
    502   ///\sa \ref EdgeSet
     500  ///\sa skeleton::ExtendableGraph
     501  ///\sa EdgeSet
    503502  class NodeSet {
    504503
     
    791790  ///
    792791  ///\param GG The type of the graph which shares its node set with this class.
    793   ///Its interface must conform with \ref GraphSkeleton.
     792  ///Its interface must conform to the
     793  ///\ref skeleton::StaticGraph "StaticGraph" concept.
    794794  ///
    795   ///It conforms to the graph interface documented under
    796   ///the description of \ref GraphSkeleton.
    797   ///\sa \ref GraphSkeleton.
    798   ///\sa \ref NodeSet.
     795  ///It conforms to the
     796  ///\ref skeleton::ExtendableGraph "ExtendableGraph" concept.
     797  ///\sa skeleton::ExtendableGraph.
     798  ///\sa NodeSet.
    799799  template<typename GG>
    800800  class EdgeSet {
     
    898898    ///Construates a new graph based on the nodeset of an existing one.
    899899    ///\param _G the base graph.
    900     ///\todo It looks like a copy constructor, but it isn't.
    901     EdgeSet(NodeGraphType &_G)
     900    explicit EdgeSet(NodeGraphType &_G)
    902901      : G(_G), nodes(_G), edges(),
    903902        first_free_edge(-1) {}
     
    906905    ///Makes a copy of an EdgeSet.
    907906    ///It will be based on the same graph.
    908     EdgeSet(const EdgeSet &_g)
     907    explicit EdgeSet(const EdgeSet &_g)
    909908      : G(_g.G), nodes(_g.G), edges(_g.edges),
    910909        first_free_edge(_g.first_free_edge) {}
  • src/hugo/skeletons/graph.h

    r873 r880  
    55///\ingroup skeletons
    66///\file
    7 ///\brief Declaration of GraphSkeleton.
     7///\brief Declaration of Graph.
    88
    99#include <hugo/invalid.h>
     
    3232    /// like @ref ListGraph or
    3333    /// @ref SmartGraph will just refer to this structure.
    34     class StaticGraphSkeleton
     34    class StaticGraph
    3535    {
    3636    public:
     
    3939      /// Defalult constructor.
    4040      ///
    41       StaticGraphSkeleton() { }
     41      StaticGraph() { }
    4242      ///Copy consructor.
    4343
    4444//       ///\todo It is not clear, what we expect from a copy constructor.
    4545//       ///E.g. How to assign the nodes/edges to each other? What about maps?
    46 //       StaticGraphSkeleton(const StaticGraphSkeleton& g) { }
     46//       StaticGraph(const StaticGraph& g) { }
    4747
    4848      /// The base type of node iterators,
     
    123123        /// Sets the iterator to the first node of \c g.
    124124        ///
    125         NodeIt(const StaticGraphSkeleton& g) { }
     125        NodeIt(const StaticGraph& g) { }
    126126        /// Node -> NodeIt conversion.
    127127
     
    130130        /// This feature necessitates that each time we
    131131        /// iterate the edge-set, the iteration order is the same.
    132         NodeIt(const StaticGraphSkeleton& g, const Node& n) { }
     132        NodeIt(const StaticGraph& g, const Node& n) { }
    133133        /// Next node.
    134134
     
    215215        ///@param n the node
    216216        ///@param g the graph
    217         OutEdgeIt(const StaticGraphSkeleton& g, const Node& n) { }
     217        OutEdgeIt(const StaticGraph& g, const Node& n) { }
    218218        /// Edge -> OutEdgeIt conversion
    219219
     
    221221        /// This feature necessitates that each time we
    222222        /// iterate the edge-set, the iteration order is the same.
    223         OutEdgeIt(const StaticGraphSkeleton& g, const Edge& e) { }
     223        OutEdgeIt(const StaticGraph& g, const Edge& e) { }
    224224        ///Next outgoing edge
    225225       
     
    264264        ///@param n the node
    265265        ///@param g the graph
    266         InEdgeIt(const StaticGraphSkeleton& g, const Node& n) { }
     266        InEdgeIt(const StaticGraph& g, const Node& n) { }
    267267        /// Edge -> InEdgeIt conversion
    268268
     
    270270        /// This feature necessitates that each time we
    271271        /// iterate the edge-set, the iteration order is the same.
    272         InEdgeIt(const StaticGraphSkeleton& g, const Edge& n) { }
     272        InEdgeIt(const StaticGraph& g, const Edge& n) { }
    273273        /// Next incoming edge
    274274
     
    308308        /// node
    309309        ///@param g the graph
    310         EdgeIt(const StaticGraphSkeleton& g) { }
     310        EdgeIt(const StaticGraph& g) { }
    311311        /// Edge -> EdgeIt conversion
    312312
     
    314314        /// This feature necessitates that each time we
    315315        /// iterate the edge-set, the iteration order is the same.
    316         EdgeIt(const StaticGraphSkeleton&, const Edge&) { }
     316        EdgeIt(const StaticGraph&, const Edge&) { }
    317317        ///Next edge
    318318       
     
    371371      /// .
    372372     
    373       ///\todo What is this?
     373      ///\todo Should it be in the concept?
    374374      ///
    375375      int nodeNum() const { return 0; }
    376376      /// .
    377       ///\todo What is this?
     377
     378      ///\todo Should it be in the concept?
    378379      ///
    379380      int edgeNum() const { return 0; }
     
    382383      ///Reference map of the nodes to type \c T.
    383384
     385      /// \ingroup skeletons
    384386      ///Reference map of the nodes to type \c T.
    385       /// \sa ReferenceSkeleton
     387      /// \sa Reference
    386388      /// \warning Making maps that can handle bool type (NodeMap<bool>)
    387389      /// needs some extra attention!
    388       template<class T> class NodeMap: public ReferenceMap< Node, T >
     390      template<class T> class NodeMap : public ReferenceMap< Node, T >
    389391      {
    390392      public:
    391393
    392394        /// .
    393         NodeMap(const StaticGraphSkeleton&) { }
     395        NodeMap(const StaticGraph&) { }
    394396        /// .
    395         NodeMap(const StaticGraphSkeleton&, T) { }
     397        NodeMap(const StaticGraph&, T) { }
    396398
    397399        ///Copy constructor
     
    404406      ///Reference map of the edges to type \c T.
    405407
     408      /// \ingroup skeletons
    406409      ///Reference map of the edges to type \c T.
    407       /// \sa ReferenceSkeleton
     410      /// \sa Reference
    408411      /// \warning Making maps that can handle bool type (EdgeMap<bool>)
    409412      /// needs some extra attention!
     
    414417
    415418        /// .
    416         EdgeMap(const StaticGraphSkeleton&) { }
     419        EdgeMap(const StaticGraph&) { }
    417420        /// .
    418         EdgeMap(const StaticGraphSkeleton&, T) { }
     421        EdgeMap(const StaticGraph&, T) { }
    419422   
    420423        ///Copy constructor
     
    430433    /// An empty non-static graph class.
    431434
    432     /// This class provides everything that \c StaticGraphSkeleton
     435    /// This class provides everything that \ref StaticGraph
    433436    /// with additional functionality which enables to build a
    434437    /// graph from scratch.
    435     class ExtendableGraphSkeleton : public StaticGraphSkeleton
     438    class ExtendableGraph : public StaticGraph
    436439    {
    437440    public:
     
    440443      /// Defalult constructor.
    441444      ///
    442       ExtendableGraphSkeleton() { }
     445      ExtendableGraph() { }
    443446      ///Add a new node to the graph.
    444447
     
    448451      ///Add a new edge to the graph.
    449452
    450       ///Add a new edge to the graph with tail node \c tail
    451       ///and head node \c head.
     453      ///Add a new edge to the graph with tail node \c t
     454      ///and head node \c h.
    452455      ///\return the new edge.
    453       Edge addEdge(Node, Node) { return INVALID; }
     456      Edge addEdge(Node h, Node t) { return INVALID; }
    454457   
    455458      /// Resets the graph.
     
    457460      /// This function deletes all edges and nodes of the graph.
    458461      /// It also frees the memory allocated to store them.
    459       /// \todo It might belong to \c ErasableGraphSkeleton.
     462      /// \todo It might belong to \ref ErasableGraph.
    460463      void clear() { }
    461464    };
     
    463466    /// An empty erasable graph class.
    464467 
    465     /// This class is an extension of \c GraphSkeleton. It also makes it
     468    /// This class is an extension of \ref ExtendableGraph. It also makes it
    466469    /// possible to erase edges or nodes.
    467     class ErasableGraphSkeleton : public ExtendableGraphSkeleton
     470    class ErasableGraph : public ExtendableGraph
    468471    {
    469472    public:
     
    472475      /// Defalult constructor.
    473476      ///
    474       ErasableGraphSkeleton() { }
     477      ErasableGraph() { }
    475478      /// Deletes a node.
    476479
  • src/hugo/smart_graph.h

    r822 r880  
    3131  ///It is also quite memory efficient, but at the price
    3232  ///that <b> it does not support node and edge deletion</b>.
    33   ///It conforms to the graph interface documented under
    34   ///the description of \ref GraphSkeleton.
    35   ///\sa \ref GraphSkeleton.
     33  ///It conforms to
     34  ///the \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
     35  ///\sa skeleton::ExtendableGraph.
    3636  ///
    3737  ///\todo Some member functions could be \c static.
     
    303303  ///feature by
    304304  ///storing shared values for the edge pairs. The usual
    305   ///\ref GraphSkeleton::EdgeMap "EdgeMap"
     305  ///\ref Graph::EdgeMap "EdgeMap"
    306306  ///can be used
    307307  ///as well.
     
    311311  ///\warning It shares the similarity with \ref SmartGraph that
    312312  ///it is not possible to delete edges or nodes from the graph.
    313   //\sa \ref SmartGraph.
     313  //\sa SmartGraph.
    314314
    315315  class SymSmartGraph : public SmartGraph
  • src/test/bfs_test.cc

    r793 r880  
    1111void check_Bfs_Compile()
    1212{
    13   typedef skeleton::StaticGraphSkeleton Graph;
     13  typedef skeleton::StaticGraph Graph;
    1414
    1515  typedef Graph::Edge Edge;
  • src/test/dfs_test.cc

    r793 r880  
    1111void check_Dfs_SmartGraph_Compile()
    1212{
    13   typedef skeleton::StaticGraphSkeleton Graph;
     13  typedef skeleton::StaticGraph Graph;
    1414
    1515  typedef Graph::Edge Edge;
  • src/test/dijkstra_test.cc

    r793 r880  
    1212{
    1313  typedef int VType;
    14   typedef skeleton::StaticGraphSkeleton Graph;
     14  typedef skeleton::StaticGraph Graph;
    1515
    1616  typedef Graph::Edge Edge;
  • src/test/graph_test.cc

    r873 r880  
    5252}
    5353
    54 //Compile GraphSkeleton
    55 template void hugo::checkCompileStaticGraph<skeleton::StaticGraphSkeleton>
    56 (skeleton::StaticGraphSkeleton &);
     54//Compile Graph
     55template void hugo::checkCompileStaticGraph<skeleton::StaticGraph>
     56(skeleton::StaticGraph &);
    5757
    58 template void hugo::checkCompileGraph<skeleton::ExtendableGraphSkeleton>
    59 (skeleton::ExtendableGraphSkeleton &);
     58template void hugo::checkCompileGraph<skeleton::ExtendableGraph>
     59(skeleton::ExtendableGraph &);
    6060
    61 template void hugo::checkCompileErasableGraph<skeleton::ErasableGraphSkeleton>
    62 (skeleton::ErasableGraphSkeleton &);
     61template void hugo::checkCompileErasableGraph<skeleton::ErasableGraph>
     62(skeleton::ErasableGraph &);
    6363
    6464//Compile SmartGraph
  • src/test/kruskal_test.cc

    r810 r880  
    1515void checkCompileKruskal()
    1616{
    17   skeleton::WriteMap<skeleton::StaticGraphSkeleton::Edge,bool> w;
     17  skeleton::WriteMap<skeleton::StaticGraph::Edge,bool> w;
    1818
    19   kruskalEdgeMap(skeleton::StaticGraphSkeleton(),
    20                  skeleton::ReadMap<skeleton::StaticGraphSkeleton::Edge,int>(),
     19  kruskalEdgeMap(skeleton::StaticGraph(),
     20                 skeleton::ReadMap<skeleton::StaticGraph::Edge,int>(),
    2121                 w);
    2222}
  • src/test/preflow_test.cc

    r859 r880  
    1414{
    1515  typedef int VType;
    16   typedef skeleton::StaticGraphSkeleton Graph;
     16  typedef skeleton::StaticGraph Graph;
    1717
    1818  typedef Graph::Node Node;
  • src/work/alpar/list_graph_demo.cc

    r426 r880  
    88
    99typedef ListGraph Graph;
    10 //typedef GraphSkeleton Graph;
     10//typedef Graph Graph;
    1111
    1212
  • src/work/alpar/smart_graph_demo.cc

    r185 r880  
    88
    99typedef SmartGraph Graph;
    10 //typedef GraphSkeleton Graph;
     10//typedef Graph Graph;
    1111
    1212
  • src/work/deba/dijkstra.h

    r698 r880  
    1919  ///This class provides an efficient implementation of %Dijkstra algorithm.
    2020  ///The edge lengths are passed to the algorithm using a
    21   ///\ref ReadMapSkeleton "readable map",
     21  ///\ref ReadMap "readable map",
    2222  ///so it is easy to change it to any kind of length.
    2323  ///
     
    3333  ///may involve in relatively time consuming process to compute the edge
    3434  ///length if it is necessary. The default map type is
    35   ///\ref GraphSkeleton::EdgeMap "Graph::EdgeMap<int>"
     35  ///\ref Graph::EdgeMap "Graph::EdgeMap<int>"
    3636  ///\param Heap The heap type used by the %Dijkstra
    3737  ///algorithm. The default
  • src/work/deba/list_graph.h

    r703 r880  
    2828  ///
    2929  ///It conforms to the graph interface documented under
    30   ///the description of \ref GraphSkeleton.
    31   ///\sa \ref GraphSkeleton.
     30  ///the description of \ref Graph.
     31  ///\sa \ref Graph.
    3232  class ListGraph {
    3333
     
    383383  ///feature by
    384384  ///storing shared values for the edge pairs. The usual
    385   ///\ref GraphSkeleton::EdgeMap "EdgeMap"
     385  ///\ref Graph::EdgeMap "EdgeMap"
    386386  ///can be used
    387387  ///as well.
  • src/work/marci/experiment/graph_wrapper.h

    r281 r880  
    162162
    163163  template<typename GraphWrapper>
    164   class GraphWrapperSkeleton {
     164  class GraphWrapper {
    165165  protected:
    166166    GraphWrapper gw;
     
    185185        GraphWrapper::NodeIt(n) { }
    186186      NodeIt(const Invalid& i) : GraphWrapper::NodeIt(i) { }
    187       NodeIt(const GraphWrapperSkeleton<GraphWrapper>& _G) :
     187      NodeIt(const GraphWrapper<GraphWrapper>& _G) :
    188188        GraphWrapper::NodeIt(_G.gw) { }
    189189    };
     
    196196        GraphWrapper::OutEdgeIt(e) { }
    197197      OutEdgeIt(const Invalid& i) : GraphWrapper::OutEdgeIt(i) { }
    198       OutEdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G, const Node& n) :
     198      OutEdgeIt(const GraphWrapper<GraphWrapper>& _G, const Node& n) :
    199199        GraphWrapper::OutEdgeIt(_G.gw, n) { }
    200200    };
     
    206206        GraphWrapper::InEdgeIt(e) { }
    207207      InEdgeIt(const Invalid& i) : GraphWrapper::InEdgeIt(i) { }
    208       InEdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G, const Node& n) :
     208      InEdgeIt(const GraphWrapper<GraphWrapper>& _G, const Node& n) :
    209209        GraphWrapper::InEdgeIt(_G.gw, n) { }
    210210    };
     
    217217        GraphWrapper::EdgeIt(e) { }
    218218      EdgeIt(const Invalid& i) : GraphWrapper::EdgeIt(i) { }
    219       EdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G) :
     219      EdgeIt(const GraphWrapper<GraphWrapper>& _G) :
    220220        GraphWrapper::EdgeIt(_G.gw) { }
    221221    };
    222222
    223223
    224     //GraphWrapperSkeleton() : gw() { }
    225     GraphWrapperSkeleton(GraphWrapper _gw) : gw(_gw) { }
     224    //GraphWrapper() : gw() { }
     225    GraphWrapper(GraphWrapper _gw) : gw(_gw) { }
    226226
    227227    //void setGraph(BaseGraph& _graph) { gw.setGraph(_graph); }
     
    270270    template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> {
    271271    public:
    272       NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
     272      NodeMap(const GraphWrapper<GraphWrapper>& _G) : 
    273273        GraphWrapper::NodeMap<T>(_G.gw) { }
    274       NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) :
     274      NodeMap(const GraphWrapper<GraphWrapper>& _G, T a) :
    275275        GraphWrapper::NodeMap<T>(_G.gw, a) { }
    276276    };
     
    278278    template<typename T> class EdgeMap : public GraphWrapper::EdgeMap<T> {
    279279    public:
    280       EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
     280      EdgeMap(const GraphWrapper<GraphWrapper>& _G) : 
    281281        GraphWrapper::EdgeMap<T>(_G.gw) { }
    282       EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) :
     282      EdgeMap(const GraphWrapper<GraphWrapper>& _G, T a) :
    283283        GraphWrapper::EdgeMap<T>(_G.gw, a) { }
    284284    };
     
    366366
    367367//   template<typename /*Graph*/GraphWrapper
    368 //   /*=typename GraphWrapperSkeleton< TrivGraphWrapper<Graph>*/ >
     368//   /*=typename GraphWrapper< TrivGraphWrapper<Graph>*/ >
    369369//   class RevGraphWrapper :
    370 //     public GraphWrapper/*GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/ {
     370//     public GraphWrapper/*GraphWrapper< TrivGraphWrapper<Graph> >*/ {
    371371//   protected:
    372372//     //Graph* graph;
     
    379379 
    380380//     //typedef typename Graph::Edge Edge;
    381 //     typedef typename GraphWrapper/*typename GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/::OutEdgeIt InEdgeIt;
    382 //     typedef typename GraphWrapper/*typename GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/::InEdgeIt OutEdgeIt;
     381//     typedef typename GraphWrapper/*typename GraphWrapper< TrivGraphWrapper<Graph> >*/::OutEdgeIt InEdgeIt;
     382//     typedef typename GraphWrapper/*typename GraphWrapper< TrivGraphWrapper<Graph> >*/::InEdgeIt OutEdgeIt;
    383383//     //typedef typename Graph::SymEdgeIt SymEdgeIt;
    384384//     //typedef typename Graph::EdgeIt EdgeIt;
    385385
    386386//     //RevGraphWrapper() : graph(0) { }
    387 //     RevGraphWrapper(GraphWrapper _gw/*BaseGraph& _graph*/) : GraphWrapper/*GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/(_gw/*TrivGraphWrapper<Graph>(_graph)*/) { }
     387//     RevGraphWrapper(GraphWrapper _gw/*BaseGraph& _graph*/) : GraphWrapper/*GraphWrapper< TrivGraphWrapper<Graph> >*/(_gw/*TrivGraphWrapper<Graph>(_graph)*/) { }
    388388   
    389389//     //void setGraph(Graph& _graph) { graph = &_graph; }
     
    430430
    431431//     template<typename T> class NodeMap :
    432 //       public GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T>
     432//       public GraphWrapper/*< TrivGraphWrapper<Graph> >*/::NodeMap<T>
    433433//     {
    434434//     public:
    435435//       NodeMap(const RevGraphWrapper<GraphWrapper>& _gw) :
    436 //      GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw) { }
     436//      GraphWrapper/*< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw) { }
    437437//       NodeMap(const RevGraphWrapper<GraphWrapper>& _gw, T a) :
    438 //      GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw, a) { }
     438//      GraphWrapper/*< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw, a) { }
    439439//     };
    440440   
    441441//     template<typename T> class EdgeMap :
    442 //       public GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T> {
     442//       public GraphWrapper/*< TrivGraphWrapper<Graph> >*/::EdgeMap<T> {
    443443//     public:
    444444//       EdgeMap(const RevGraphWrapper<GraphWrapper>& _gw) :
    445 //      GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw) { }
     445//      GraphWrapper/*< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw) { }
    446446//       EdgeMap(const RevGraphWrapper<GraphWrapper>& _gw, T a) :
    447 //      GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw, a) { }
     447//      GraphWrapper/*< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw, a) { }
    448448//     };
    449449//   };
    450450
    451451  template<typename GraphWrapper>
    452   class RevGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
     452  class RevGraphWrapper : public GraphWrapper<GraphWrapper> {
    453453  public:
    454     typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
    455     typedef typename GraphWrapperSkeleton<GraphWrapper>::Edge Edge;
     454    typedef typename GraphWrapper<GraphWrapper>::Node Node;
     455    typedef typename GraphWrapper<GraphWrapper>::Edge Edge;
    456456    //FIXME
    457457    //If GraphWrapper::OutEdgeIt is not defined
     
    462462    //Unfortunately all the typedefs are instantiated in templates,
    463463    //unlike other stuff
    464     typedef typename GraphWrapperSkeleton<GraphWrapper>::OutEdgeIt InEdgeIt;
    465     typedef typename GraphWrapperSkeleton<GraphWrapper>::InEdgeIt OutEdgeIt;
     464    typedef typename GraphWrapper<GraphWrapper>::OutEdgeIt InEdgeIt;
     465    typedef typename GraphWrapper<GraphWrapper>::InEdgeIt OutEdgeIt;
    466466
    467467    RevGraphWrapper(GraphWrapper _gw) :
    468       GraphWrapperSkeleton<GraphWrapper>(_gw) { } 
     468      GraphWrapper<GraphWrapper>(_gw) { } 
    469469
    470470    Node head(const Edge& e) const
    471       { return GraphWrapperSkeleton<GraphWrapper>::tail(e); }
     471      { return GraphWrapper<GraphWrapper>::tail(e); }
    472472    Node tail(const Edge& e) const
    473       { return GraphWrapperSkeleton<GraphWrapper>::head(e); }
     473      { return GraphWrapper<GraphWrapper>::head(e); }
    474474  };
    475475
    476476  //Subgraph on the same node-set and partial edge-set
    477477  template<typename GraphWrapper, typename EdgeFilterMap>
    478   class SubGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
     478  class SubGraphWrapper : public GraphWrapper<GraphWrapper> {
    479479  protected:
    480480    EdgeFilterMap* filter_map;
    481481  public:
    482     typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
    483     typedef typename GraphWrapperSkeleton<GraphWrapper>::NodeIt NodeIt;
    484     typedef typename GraphWrapperSkeleton<GraphWrapper>::Edge Edge;
    485     typedef typename GraphWrapperSkeleton<GraphWrapper>::EdgeIt EdgeIt;
    486     typedef typename GraphWrapperSkeleton<GraphWrapper>::InEdgeIt InEdgeIt;
    487     typedef typename GraphWrapperSkeleton<GraphWrapper>::OutEdgeIt OutEdgeIt;
     482    typedef typename GraphWrapper<GraphWrapper>::Node Node;
     483    typedef typename GraphWrapper<GraphWrapper>::NodeIt NodeIt;
     484    typedef typename GraphWrapper<GraphWrapper>::Edge Edge;
     485    typedef typename GraphWrapper<GraphWrapper>::EdgeIt EdgeIt;
     486    typedef typename GraphWrapper<GraphWrapper>::InEdgeIt InEdgeIt;
     487    typedef typename GraphWrapper<GraphWrapper>::OutEdgeIt OutEdgeIt;
    488488
    489489    SubGraphWrapper(GraphWrapper _gw, EdgeFilterMap& _filter_map) :
    490       GraphWrapperSkeleton<GraphWrapper>(_gw), filter_map(&_filter_map) { } 
     490      GraphWrapper<GraphWrapper>(_gw), filter_map(&_filter_map) { } 
    491491
    492492    template<typename I> I& first(I& i) const {
     
    678678
    679679  template<typename GraphWrapper>
    680   class UndirGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
     680  class UndirGraphWrapper : public GraphWrapper<GraphWrapper> {
    681681  protected:
    682682//    GraphWrapper gw;
     
    685685    //typedef GraphWrapper BaseGraph;
    686686
    687     typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
    688     typedef typename GraphWrapperSkeleton<GraphWrapper>::NodeIt NodeIt;
     687    typedef typename GraphWrapper<GraphWrapper>::Node Node;
     688    typedef typename GraphWrapper<GraphWrapper>::NodeIt NodeIt;
    689689
    690690    //private:
    691691    //FIXME ezeknek valojaban a GraphWrapper megfelelo dolgai kellene hogy
    692692    //legyenek, at kell irni
    693     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
     693    typedef typename /*GraphWrapper<GraphWrapper>*/
    694694    GraphWrapper::Edge GraphEdge;
    695     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
     695    typedef typename /*GraphWrapper<GraphWrapper>*/
    696696    GraphWrapper::OutEdgeIt GraphOutEdgeIt;
    697     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
     697    typedef typename /*GraphWrapper<GraphWrapper>*/
    698698    GraphWrapper::InEdgeIt GraphInEdgeIt;
    699699    //public:
     
    701701    //UndirGraphWrapper() : graph(0) { }
    702702    UndirGraphWrapper(GraphWrapper _gw) :
    703       GraphWrapperSkeleton<GraphWrapper>(_gw) { } 
     703      GraphWrapper<GraphWrapper>(_gw) { } 
    704704
    705705    //UndirGraphWrapper(GraphWrapper _gw) : gw(_gw) { }
     
    865865
    866866//     template<typename T> class EdgeMap :
    867 //       public GraphWrapperSkeleton<GraphWrapper>::EdgeMap<T> {
     867//       public GraphWrapper<GraphWrapper>::EdgeMap<T> {
    868868//     public:
    869869//       EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G) :
    870 //      GraphWrapperSkeleton<GraphWrapper>::EdgeMap<T>(_G.gw) { }
     870//      GraphWrapper<GraphWrapper>::EdgeMap<T>(_G.gw) { }
    871871//       EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G, T a) :
    872872//      GraphWrapper::EdgeMap<T>(_G.gw, a) { }
     
    948948
    949949  template<typename GraphWrapper, typename Number, typename FlowMap, typename CapacityMap>
    950   class ResGraphWrapper : public GraphWrapperSkeleton<GraphWrapper>{
     950  class ResGraphWrapper : public GraphWrapper<GraphWrapper>{
    951951  public:
    952952    //typedef Graph BaseGraph;
    953953    //typedef TrivGraphWrapper<const Graph> GraphWrapper;
    954     typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
    955     typedef typename GraphWrapperSkeleton<GraphWrapper>::NodeIt NodeIt;
     954    typedef typename GraphWrapper<GraphWrapper>::Node Node;
     955    typedef typename GraphWrapper<GraphWrapper>::NodeIt NodeIt;
    956956  private:
    957     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
     957    typedef typename /*GraphWrapper<GraphWrapper>*/
    958958    GraphWrapper::OutEdgeIt OldOutEdgeIt;
    959     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
     959    typedef typename /*GraphWrapper<GraphWrapper>*/
    960960    GraphWrapper::InEdgeIt OldInEdgeIt;
    961961  protected:
     
    968968    ResGraphWrapper(const GraphWrapper& _gw, FlowMap& _flow,
    969969                    const CapacityMap& _capacity) :
    970       GraphWrapperSkeleton<GraphWrapper>(_gw),
     970      GraphWrapper<GraphWrapper>(_gw),
    971971      flow(&_flow), capacity(&_capacity) { }
    972972
     
    12651265  //Subgraph on the same node-set and partial edge-set
    12661266  template<typename GraphWrapper, typename FirstOutEdgesMap>
    1267   class ErasingFirstGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
     1267  class ErasingFirstGraphWrapper : public GraphWrapper<GraphWrapper> {
    12681268  protected:
    12691269    FirstOutEdgesMap* first_out_edges;
    12701270  public:
    1271     typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
    1272     typedef typename GraphWrapperSkeleton<GraphWrapper>::NodeIt NodeIt;
    1273     typedef typename GraphWrapperSkeleton<GraphWrapper>::Edge Edge;
    1274     typedef typename GraphWrapperSkeleton<GraphWrapper>::EdgeIt EdgeIt;
    1275     typedef typename GraphWrapperSkeleton<GraphWrapper>::InEdgeIt InEdgeIt;
    1276     typedef typename GraphWrapperSkeleton<GraphWrapper>::OutEdgeIt OutEdgeIt;
     1271    typedef typename GraphWrapper<GraphWrapper>::Node Node;
     1272    typedef typename GraphWrapper<GraphWrapper>::NodeIt NodeIt;
     1273    typedef typename GraphWrapper<GraphWrapper>::Edge Edge;
     1274    typedef typename GraphWrapper<GraphWrapper>::EdgeIt EdgeIt;
     1275    typedef typename GraphWrapper<GraphWrapper>::InEdgeIt InEdgeIt;
     1276    typedef typename GraphWrapper<GraphWrapper>::OutEdgeIt OutEdgeIt;
    12771277
    12781278    ErasingFirstGraphWrapper(GraphWrapper _gw, FirstOutEdgesMap& _first_out_edges) :
    1279       GraphWrapperSkeleton<GraphWrapper>(_gw), first_out_edges(&_first_out_edges) { } 
     1279      GraphWrapper<GraphWrapper>(_gw), first_out_edges(&_first_out_edges) { } 
    12801280
    12811281    template<typename I> I& first(I& i) const {
  • src/work/marci/experiment/graph_wrapper_1.h

    r298 r880  
    759759
    760760//     template<typename T> class EdgeMap :
    761 //       public GraphWrapperSkeleton<Graph>::EdgeMap<T> {
     761//       public GraphWrapper<Graph>::EdgeMap<T> {
    762762//     public:
    763763//       EdgeMap(const UndirGraphWrapper<Graph>& _G) :
    764 //      GraphWrapperSkeleton<Graph>::EdgeMap<T>(_G.gw) { }
     764//      GraphWrapper<Graph>::EdgeMap<T>(_G.gw) { }
    765765//       EdgeMap(const UndirGraphWrapper<Graph>& _G, T a) :
    766766//      Graph::EdgeMap<T>(_G.gw, a) { }
  • src/work/peter/edgepathgraph.h

    r826 r880  
    297297
    298298    ///Read/write/reference map of the nodes to type \c T.
    299     /// \sa MemoryMapSkeleton
     299    /// \sa MemoryMap
    300300    /// \todo We may need copy constructor
    301301    /// \todo We may need conversion from other nodetype
     
    338338    ///It behaves exactly in the same way as \ref NodeMap.
    339339    /// \sa NodeMap
    340     /// \sa MemoryMapSkeleton
     340    /// \sa MemoryMap
    341341    /// \todo We may need copy constructor
    342342    /// \todo We may need conversion from other edgetype
     
    375375  ///
    376376  /// \todo This blabla could be replaced by a sepatate description about
    377   /// Skeletons.
     377  /// s.
    378378  ///
    379379  /// It can be used for checking the interface compatibility,
  • src/work/peter/hierarchygraph.h

    r826 r880  
    424424
    425425    ///Read/write/reference map of the nodes to type \c T.
    426     /// \sa MemoryMapSkeleton
     426    /// \sa MemoryMap
    427427    /// \todo We may need copy constructor
    428428    /// \todo We may need conversion from other nodetype
     
    483483    ///It behaves exactly in the same way as \ref NodeMap.
    484484    /// \sa NodeMap
    485     /// \sa MemoryMapSkeleton
     485    /// \sa MemoryMap
    486486    /// \todo We may need copy constructor
    487487    /// \todo We may need conversion from other edgetype
     
    538538  ///
    539539  /// \todo This blabla could be replaced by a sepatate description about
    540   /// Skeletons.
     540  /// s.
    541541  ///
    542542  /// It can be used for checking the interface compatibility,
Note: See TracChangeset for help on using the changeset viewer.