COIN-OR::LEMON - Graph Library

Ignore:
Timestamp:
04/07/04 12:57:58 (17 years ago)
Author:
marci
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@430
Message:

gw

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/work/marci/graph_wrapper.h

    r311 r312  
    77namespace hugo {
    88
    9   template<typename Graph>
    10   class TrivGraphWrapper {
    11   protected:
    12     Graph* graph;
    13  
    14   public:
    15 //    typedef Graph BaseGraph;
    16     typedef Graph ParentGraph;
    17 
    18 //     TrivGraphWrapper() : graph(0) { }
    19     TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }
    20 //     void setGraph(Graph& _graph) { graph = &_graph; }
    21 //     Graph& getGraph() const { return *graph; }
    22 
    23     typedef typename Graph::Node Node;
    24     class NodeIt : public Graph::NodeIt {
    25     public:
    26       NodeIt() { }
    27       NodeIt(const typename Graph::NodeIt& n) : Graph::NodeIt(n) { }
    28 //      NodeIt(const typename BaseGraph::NodeIt& n) : Graph::NodeIt(n) { }
    29       NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
    30       NodeIt(const TrivGraphWrapper<Graph>& _G) :
    31         Graph::NodeIt(*(_G.graph)) { }
    32 //      operator typename BaseGraph::NodeIt() {
    33 //      return typename BaseGraph::NodeIt(this->Graph::NodeIt);
    34 //      }
    35     };
    36     typedef typename Graph::Edge Edge;
    37     class OutEdgeIt : public Graph::OutEdgeIt {
    38     public:
    39       OutEdgeIt() { }
    40       OutEdgeIt(const typename Graph::OutEdgeIt& e) : Graph::OutEdgeIt(e) { }
    41       OutEdgeIt(const Invalid& i) : Graph::OutEdgeIt(i) { }
    42       OutEdgeIt(const TrivGraphWrapper<Graph>& _G, const Node& n) :
    43         Graph::OutEdgeIt(*(_G.graph), n) { }
    44     };
    45     class InEdgeIt : public Graph::InEdgeIt {
    46     public:
    47       InEdgeIt() { }
    48       InEdgeIt(const typename Graph::InEdgeIt& e) : Graph::InEdgeIt(e) { }
    49       InEdgeIt(const Invalid& i) : Graph::InEdgeIt(i) { }
    50       InEdgeIt(const TrivGraphWrapper<Graph>& _G, const Node& n) :
    51         Graph::InEdgeIt(*(_G.graph), n) { }
    52     };
    53     //typedef typename Graph::SymEdgeIt SymEdgeIt;
    54     class EdgeIt : public Graph::EdgeIt {
    55     public:
    56       EdgeIt() { }
    57       EdgeIt(const typename Graph::EdgeIt& e) : Graph::EdgeIt(e) { }
    58       EdgeIt(const Invalid& i) : Graph::EdgeIt(i) { }
    59       EdgeIt(const TrivGraphWrapper<Graph>& _G) :
    60         Graph::EdgeIt(*(_G.graph)) { }
    61     };
    62 
    63     NodeIt& first(NodeIt& i) const {
    64       i=NodeIt(*this);
    65       return i;
    66     }
    67 //     template<typename I> I& first(I& i) const {
    68 //       i=I(*this);
     9//   template<typename Graph>
     10//   class TrivGraphWrapper {
     11//   protected:
     12//     Graph* graph;
     13 
     14//   public:
     15// //    typedef Graph BaseGraph;
     16//     typedef Graph ParentGraph;
     17
     18// //     TrivGraphWrapper() : graph(0) { }
     19//     TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }
     20// //     void setGraph(Graph& _graph) { graph = &_graph; }
     21// //     Graph& getGraph() const { return *graph; }
     22
     23//     typedef typename Graph::Node Node;
     24//     class NodeIt : public Graph::NodeIt {
     25//     public:
     26//       NodeIt() { }
     27//       NodeIt(const typename Graph::NodeIt& n) : Graph::NodeIt(n) { }
     28//       NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
     29//       NodeIt(const TrivGraphWrapper<Graph>& _G) :
     30//      Graph::NodeIt(*(_G.graph)) { }
     31//     };
     32//     typedef typename Graph::Edge Edge;
     33//     class OutEdgeIt : public Graph::OutEdgeIt {
     34//     public:
     35//       OutEdgeIt() { }
     36//       OutEdgeIt(const typename Graph::OutEdgeIt& e) : Graph::OutEdgeIt(e) { }
     37//       OutEdgeIt(const Invalid& i) : Graph::OutEdgeIt(i) { }
     38//       OutEdgeIt(const TrivGraphWrapper<Graph>& _G, const Node& n) :
     39//      Graph::OutEdgeIt(*(_G.graph), n) { }
     40//     };
     41//     class InEdgeIt : public Graph::InEdgeIt {
     42//     public:
     43//       InEdgeIt() { }
     44//       InEdgeIt(const typename Graph::InEdgeIt& e) : Graph::InEdgeIt(e) { }
     45//       InEdgeIt(const Invalid& i) : Graph::InEdgeIt(i) { }
     46//       InEdgeIt(const TrivGraphWrapper<Graph>& _G, const Node& n) :
     47//      Graph::InEdgeIt(*(_G.graph), n) { }
     48//     };
     49//     //typedef typename Graph::SymEdgeIt SymEdgeIt;
     50//     class EdgeIt : public Graph::EdgeIt {
     51//     public:
     52//       EdgeIt() { }
     53//       EdgeIt(const typename Graph::EdgeIt& e) : Graph::EdgeIt(e) { }
     54//       EdgeIt(const Invalid& i) : Graph::EdgeIt(i) { }
     55//       EdgeIt(const TrivGraphWrapper<Graph>& _G) :
     56//      Graph::EdgeIt(*(_G.graph)) { }
     57//     };
     58
     59//     NodeIt& first(NodeIt& i) const {
     60//       i=NodeIt(*this);
    6961//       return i;
    7062//     }
    71     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
    72       i=OutEdgeIt(*this, p);
    73       return i;
    74     }
    75     InEdgeIt& first(InEdgeIt& i, const Node& p) const {
    76       i=InEdgeIt(*this, p);
    77       return i;
    78     }
    79     EdgeIt& first(EdgeIt& i) const {
    80       i=EdgeIt(*this);
    81       return i;
    82     }
    83 //     template<typename I, typename P> I& first(I& i, const P& p) const {
    84 //       i=I(*this, p);
     63//     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
     64//       i=OutEdgeIt(*this, p);
    8565//       return i;
    8666//     }
    87    
    88 //    template<typename I> I getNext(const I& i) const {
    89 //      return graph->getNext(i); }
    90 //    template<typename I> I& next(I &i) const { graph->next(i); return i; }   
    91     NodeIt& next(NodeIt& i) const { graph->next(i); return i; }
    92     OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i); return i; }
    93     InEdgeIt& next(InEdgeIt& i) const { graph->next(i); return i; }
    94     EdgeIt& next(EdgeIt& i) const { graph->next(i); return i; }
    95 
    96     template< typename It > It first() const {
    97       It e; this->first(e); return e; }
    98 
    99     template< typename It > It first(const Node& v) const {
    100       It e; this->first(e, v); return e; }
    101 
    102     Node head(const Edge& e) const { return graph->head(e); }
    103     Node tail(const Edge& e) const { return graph->tail(e); }
    104 
    105     template<typename I> bool valid(const I& i) const {
    106       return graph->valid(i); }
    107  
    108     //template<typename I> void setInvalid(const I &i);
    109     //{ return graph->setInvalid(i); }
    110 
    111     int nodeNum() const { return graph->nodeNum(); }
    112     int edgeNum() const { return graph->edgeNum(); }
    113  
    114     template<typename I> Node aNode(const I& e) const {
    115       return graph->aNode(e); }
    116     template<typename I> Node bNode(const I& e) const {
    117       return graph->bNode(e); }
    118  
    119     Node addNode() const { return graph->addNode(); }
    120     Edge addEdge(const Node& tail, const Node& head) const {
    121       return graph->addEdge(tail, head); }
    122  
    123     template<typename I> void erase(const I& i) const { graph->erase(i); }
    124  
    125     void clear() const { graph->clear(); }
    126    
    127     template<typename T> class NodeMap : public Graph::NodeMap<T> {
    128     public:
    129       NodeMap(const TrivGraphWrapper<Graph>& _G) : 
    130         Graph::NodeMap<T>(*(_G.graph)) { }
    131       NodeMap(const TrivGraphWrapper<Graph>& _G, T a) :
    132         Graph::NodeMap<T>(*(_G.graph), a) { }
    133     };
    134 
    135     template<typename T> class EdgeMap : public Graph::EdgeMap<T> {
    136     public:
    137       EdgeMap(const TrivGraphWrapper<Graph>& _G) : 
    138         Graph::EdgeMap<T>(*(_G.graph)) { }
    139       EdgeMap(const TrivGraphWrapper<Graph>& _G, T a) :
    140         Graph::EdgeMap<T>(*(_G.graph), a) { }
    141     };
    142 
    143 //     template<typename Map, typename T> class NodeMapWrapper {
    144 //     protected:
    145 //       Map* map;
    146 //     public:
    147 //       NodeMapWrapper(Map& _map) : map(&_map) { }
    148 //       void set(Node n, T a) { map->set(n, a); }
    149 //       T get(Node n) const { return map->get(n); }
    150 //     };
    151 
    152 //     template<typename Map, typename T> class EdgeMapWrapper {
    153 //     protected:
    154 //       Map* map;
    155 //     public:
    156 //       EdgeMapWrapper(Map& _map) : map(&_map) { }
    157 //       void set(Edge n, T a) { map->set(n, a); }
    158 //       T get(Edge n) const { return map->get(n); }
    159 //     };
    160   };
     67//     InEdgeIt& first(InEdgeIt& i, const Node& p) const {
     68//       i=InEdgeIt(*this, p);
     69//       return i;
     70//     }
     71//     EdgeIt& first(EdgeIt& i) const {
     72//       i=EdgeIt(*this);
     73//       return i;
     74//     }
     75// //     template<typename I> I& first(I& i) const {
     76// //       i=I(*this);
     77// //       return i;
     78// //     }
     79// //     template<typename I, typename P> I& first(I& i, const P& p) const {
     80// //       i=I(*this, p);
     81// //       return i;
     82// //     }
     83   
     84// //    template<typename I> I getNext(const I& i) const {
     85// //      return graph->getNext(i); }
     86
     87//     NodeIt& next(NodeIt& i) const { graph->next(i); return i; }
     88//     OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i); return i; }
     89//     InEdgeIt& next(InEdgeIt& i) const { graph->next(i); return i; }
     90//     EdgeIt& next(EdgeIt& i) const { graph->next(i); return i; }
     91// //    template<typename I> I& next(I &i) const { graph->next(i); return i; }   
     92//     template< typename It > It first() const {
     93//       It e; this->first(e); return e; }
     94
     95//     template< typename It > It first(const Node& v) const {
     96//       It e; this->first(e, v); return e; }
     97
     98//     Node head(const Edge& e) const { return graph->head(e); }
     99//     Node tail(const Edge& e) const { return graph->tail(e); }
     100
     101//     template<typename I> bool valid(const I& i) const {
     102//       return graph->valid(i); }
     103 
     104//     //template<typename I> void setInvalid(const I &i);
     105//     //{ return graph->setInvalid(i); }
     106
     107//     int nodeNum() const { return graph->nodeNum(); }
     108//     int edgeNum() const { return graph->edgeNum(); }
     109 
     110//     template<typename I> Node aNode(const I& e) const {
     111//       return graph->aNode(e); }
     112//     template<typename I> Node bNode(const I& e) const {
     113//       return graph->bNode(e); }
     114 
     115//     Node addNode() const { return graph->addNode(); }
     116//     Edge addEdge(const Node& tail, const Node& head) const {
     117//       return graph->addEdge(tail, head); }
     118 
     119//     template<typename I> void erase(const I& i) const { graph->erase(i); }
     120 
     121//     void clear() const { graph->clear(); }
     122   
     123//     template<typename T> class NodeMap : public Graph::NodeMap<T> {
     124//     public:
     125//       NodeMap(const TrivGraphWrapper<Graph>& _G) : 
     126//      Graph::NodeMap<T>(*(_G.graph)) { }
     127//       NodeMap(const TrivGraphWrapper<Graph>& _G, T a) :
     128//      Graph::NodeMap<T>(*(_G.graph), a) { }
     129//     };
     130
     131//     template<typename T> class EdgeMap : public Graph::EdgeMap<T> {
     132//     public:
     133//       EdgeMap(const TrivGraphWrapper<Graph>& _G) : 
     134//      Graph::EdgeMap<T>(*(_G.graph)) { }
     135//       EdgeMap(const TrivGraphWrapper<Graph>& _G, T a) :
     136//      Graph::EdgeMap<T>(*(_G.graph), a) { }
     137//     };
     138
     139// //     template<typename Map, typename T> class NodeMapWrapper {
     140// //     protected:
     141// //       Map* map;
     142// //     public:
     143// //       NodeMapWrapper(Map& _map) : map(&_map) { }
     144// //       void set(Node n, T a) { map->set(n, a); }
     145// //       T get(Node n) const { return map->get(n); }
     146// //     };
     147
     148// //     template<typename Map, typename T> class EdgeMapWrapper {
     149// //     protected:
     150// //       Map* map;
     151// //     public:
     152// //       EdgeMapWrapper(Map& _map) : map(&_map) { }
     153// //       void set(Edge n, T a) { map->set(n, a); }
     154// //       T get(Edge n) const { return map->get(n); }
     155// //     };
     156//   };
    161157
    162158
     
    177173    typedef typename Graph::Node Node;
    178174    class NodeIt : public Graph::NodeIt {
     175      typedef typename Graph::NodeIt GraphNodeIt;
    179176    public:
    180177      NodeIt() { }
     
    183180      NodeIt(const GraphWrapper<Graph>& _G) :
    184181        Graph::NodeIt(*(_G.graph)) { }
     182//      operator Node() const {
     183//      std::cout << "ize" << std::endl;
     184//      return Node(this->GraphNodeIt);
     185//      }
    185186    };
    186187    typedef typename Graph::Edge Edge;
    187188    class OutEdgeIt : public Graph::OutEdgeIt {
     189      typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
    188190    public:
    189191      OutEdgeIt() { }
     
    192194      OutEdgeIt(const GraphWrapper<Graph>& _G, const Node& n) :
    193195        Graph::OutEdgeIt(*(_G.graph), n) { }
     196//      operator Edge() const {
     197//      std::cout << "ize" << std::endl;
     198//      return Edge(this->GraphOutEdgeIt);
     199//      }
    194200    };
    195201    class InEdgeIt : public Graph::InEdgeIt {
     202      typedef typename Graph::InEdgeIt GraphInEdgeIt;
    196203    public:
    197204      InEdgeIt() { }
     
    200207      InEdgeIt(const GraphWrapper<Graph>& _G, const Node& n) :
    201208        Graph::InEdgeIt(*(_G.graph), n) { }
     209//      operator Edge() const {
     210//      std::cout << "ize" << std::endl;
     211//      return Edge(this->InOutEdgeIt);
     212//      }
    202213    };
    203214    //typedef typename Graph::SymEdgeIt SymEdgeIt;
    204215    class EdgeIt : public Graph::EdgeIt {
     216      typedef typename Graph::EdgeIt GraphEdgeIt;
    205217    public:
    206218      EdgeIt() { }
     
    209221      EdgeIt(const GraphWrapper<Graph>& _G) :
    210222        Graph::EdgeIt(*(_G.graph)) { }
     223//      operator Edge() const {
     224//      std::cout << "ize" << std::endl;
     225//      return Edge(this->GraphEdgeIt);
     226//      }
    211227    };
    212228   
    213229    NodeIt& first(NodeIt& i) const {
    214230      i=NodeIt(*this);
     231      return i;
     232    }
     233    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
     234      i=OutEdgeIt(*this, p);
     235      return i;
     236    }
     237    InEdgeIt& first(InEdgeIt& i, const Node& p) const {
     238      i=InEdgeIt(*this, p);
     239      return i;
     240    }
     241    EdgeIt& first(EdgeIt& i) const {
     242      i=EdgeIt(*this);
    215243      return i;
    216244    }
     
    219247//       return i;
    220248//     }
    221     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
    222       i=OutEdgeIt(*this, p);
    223       return i;
    224     }
    225     InEdgeIt& first(InEdgeIt& i, const Node& p) const {
    226       i=InEdgeIt(*this, p);
    227       return i;
    228     }
    229     EdgeIt& first(EdgeIt& i) const {
    230       i=EdgeIt(*this);
    231       return i;
    232     }
    233249//     template<typename I, typename P> I& first(I& i, const P& p) const {
    234250//       i=I(*this, p);
     
    238254//    template<typename I> I getNext(const I& i) const {
    239255//      return gw.getNext(i); }
    240 //    template<typename I> I& next(I &i) const { graph->next(i); return i; }   
     256
    241257    NodeIt& next(NodeIt& i) const { graph->next(i); return i; }
    242258    OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i); return i; }
    243259    InEdgeIt& next(InEdgeIt& i) const { graph->next(i); return i; }
    244260    EdgeIt& next(EdgeIt& i) const { graph->next(i); return i; }   
    245 
     261//    template<typename I> I& next(I &i) const { graph->next(i); return i; }   
    246262    template< typename It > It first() const {
    247263      It e; this->first(e); return e; }
     
    252268    Node head(const Edge& e) const { return graph->head(e); }
    253269    Node tail(const Edge& e) const { return graph->tail(e); }
     270//    Node tail(const OutEdgeIt& e) const { return graph->tail(Edge(e)); }
    254271
    255272    template<typename I> bool valid(const I& i) const {
Note: See TracChangeset for help on using the changeset viewer.