COIN-OR::LEMON - Graph Library

Changeset 318:7bec4e8fb7dd in lemon-0.x


Ignore:
Timestamp:
04/14/04 13:26:12 (16 years ago)
Author:
marci
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@436
Message:

gw

File:
1 edited

Legend:

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

    r317 r318  
    3939      operator Node() const { return Node(typename Graph::Node(n)); }
    4040    };
    41 //     class Node : public Graph::Node {
    42 //     public:
    43 //       Node() { }
    44 //       Node(const typename Graph::Node& n) : Graph::Node(n) { }
    45 //       Node(const Invalid& i) : Graph::Node(i) { }
    46 //     };
    47 //     class NodeIt : public Graph::NodeIt {
    48 //       typedef typename Graph::NodeIt GraphNodeIt;
    49 //     public:
    50 //       NodeIt() { }
    51 //       NodeIt(const typename Graph::NodeIt& n) : Graph::NodeIt(n) { }
    52 //       NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
    53 //       NodeIt(const GraphWrapper<Graph>& _G) :
    54 //      Graph::NodeIt(*(_G.graph)) { }
    55 //       operator Node() const {
    56 //      return Node(typename Graph::Node(
    57 //                    static_cast<typename Graph::NodeIt>(*this)
    58 //                    ));
    59 //       }
    60 //     };
    6141//    typedef typename Graph::Edge Edge;
    6242    class Edge : public Graph::Edge {
     
    125105//     }
    126106   
    127 //    template<typename I> I getNext(const I& i) const {
    128 //      return gw.getNext(i); }
    129 
    130107    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
    131108    OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i.e); return i; }
     
    143120    Node tail(const Edge& e) const {
    144121      return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
    145 //    Node tail(const OutEdgeIt& e) const { return graph->tail(Edge(e)); }
    146122
    147123    bool valid(const Node& n) const {
     
    183159      NodeMap(const GraphWrapper<Graph>& _G, T a) :
    184160        Graph::NodeMap<T>(*(_G.graph), a) { }
    185 //       T operator[](const Node& n) const {
    186 //      return Graph::NodeMap<T>::operator[](n);
    187 //       }
    188161    };
    189162
     
    226199//       return graph->first(i, p); }
    227200
    228 //     template<typename I> I getNext(const I& i) const {
    229 //       return graph->getNext(i); }
    230201//     template<typename I> I& next(I &i) const { return graph->next(i); }   
    231202
     
    498469    Node bNode(const InEdgeIt& e) const { return Node(graph->bNode(e.e)); }
    499470   
    500     //template<typename I> I getNext(const I& i) const {
    501     //  return gw.getNext(i);
    502     //}
    503471//     template<typename I> I& next(I &i) const {
    504472//       graph->next(i);
     
    639607//     }
    640608
    641 //     //template<typename I> I getNext(const I& i) const {
    642 //     //  return gw.getNext(i);
    643 //     //}
    644609// //     template<typename I> I& next(I &i) const {
    645610// //       graph->next(i);
     
    655620//       It e; this->first(e, v); return e; }
    656621//   };
    657 
    658 //   template<typename GraphWrapper>
    659 //   class UndirGraphWrapper {
    660 //   protected:
    661 //     //Graph* graph;
    662 //     GraphWrapper gw;
    663 
    664 //   public:
    665 //     typedef GraphWrapper ParentGraph;
    666 
    667 //     typedef typename GraphWrapper::Node Node;
    668 //     typedef typename GraphWrapper::NodeIt NodeIt;
    669 
    670 //     //typedef typename Graph::Edge Edge;
    671 //     //typedef typename Graph::OutEdgeIt OutEdgeIt;
    672 //     //typedef typename Graph::InEdgeIt InEdgeIt;
    673 //     //typedef typename Graph::SymEdgeIt SymEdgeIt;
    674 //     //typedef typename Graph::EdgeIt EdgeIt;
    675 
    676 //     //private:
    677 //     typedef typename GraphWrapper::Edge GraphEdge;
    678 //     typedef typename GraphWrapper::OutEdgeIt GraphOutEdgeIt;
    679 //     typedef typename GraphWrapper::InEdgeIt GraphInEdgeIt;
    680 //     //public:
    681 
    682 //     //UndirGraphWrapper() : graph(0) { }
    683 //     UndirGraphWrapper(GraphWrapper _gw) : gw(_gw) { }
    684 
    685 //     //void setGraph(Graph& _graph) { graph = &_graph; }
    686 //     //Graph& getGraph() const { return (*graph); }
    687  
    688 //     class Edge {
    689 //       friend class UndirGraphWrapper<GraphWrapper>;
    690 //       bool out_or_in; //true iff out
    691 //       GraphOutEdgeIt out;
    692 //       GraphInEdgeIt in;
    693 //     public:
    694 //       Edge() : out_or_in(), out(), in() { }
    695 //       Edge(const Invalid& i) : out_or_in(false), out(), in(i) { }
    696 //       operator GraphEdge() const {
    697 //      if (out_or_in) return(out); else return(in);
    698 //       }
    699 //       friend bool operator==(const Edge& u, const Edge& v) {
    700 //      if (v.out_or_in)
    701 //        return (u.out_or_in && u.out==v.out);
    702 //      else
    703 //        return (!u.out_or_in && u.in==v.in);
    704 //       }
    705 //       friend bool operator!=(const Edge& u, const Edge& v) {
    706 //      if (v.out_or_in)
    707 //        return (!u.out_or_in || u.out!=v.out);
    708 //      else
    709 //        return (u.out_or_in || u.in!=v.in);
    710 //       }
    711 //     };
    712 
    713 //     class OutEdgeIt : public Edge {
    714 //       friend class UndirGraphWrapper<GraphWrapper>;
    715 //     public:
    716 //       OutEdgeIt() : Edge() { }
    717 //       OutEdgeIt(const Invalid& i) : Edge(i) { }
    718 //       OutEdgeIt(const UndirGraphWrapper<GraphWrapper>& _G, const Node& n)
    719 //      : Edge() {
    720 //      out_or_in=true;
    721 //      _G.gw.first(out, n);
    722 //      if (!(_G.gw.valid(out))) {
    723 //        out_or_in=false;
    724 //        _G.gw.first(in, n);
    725 //      }
    726 //       }
    727 //     };
    728 
    729 //     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
    730 //       e.out_or_in=true;
    731 //       gw.first(e.out, n);
    732 //       if (!(gw.valid(e.out))) {
    733 //      e.out_or_in=false;
    734 //      gw.first(e.in, n);
    735 //       }
    736 //       return e;
    737 //     }
    738 
    739 //     OutEdgeIt& next(OutEdgeIt& e) const {
    740 //       if (e.out_or_in) {
    741 //      Node n=gw.tail(e.out);
    742 //      gw.next(e.out);
    743 //      if (!gw.valid(e.out)) {
    744 //        e.out_or_in=false;
    745 //        gw.first(e.in, n);
    746 //      }
    747 //       } else {
    748 //      gw.next(e.in);
    749 //       }
    750 //       return e;
    751 //     }
    752 
    753 //     Node aNode(const OutEdgeIt& e) const {
    754 //       if (e.out_or_in) return gw.tail(e); else return gw.head(e); }
    755 //     Node bNode(const OutEdgeIt& e) const {
    756 //       if (e.out_or_in) return gw.head(e); else return gw.tail(e); }
    757 
    758 //     typedef OutEdgeIt InEdgeIt;
    759 
    760 //     template<typename I> I& first(I& i) const { return gw.first(i); }
    761 // //     template<typename I, typename P> I& first(I& i, const P& p) const {
    762 // //       return graph->first(i, p); }
    763    
    764 //     template<typename I> I getNext(const I& i) const {
    765 //       return gw.getNext(i); }
    766 //     template<typename I> I& next(I &i) const { return gw.next(i); }   
    767 
    768 //     template< typename It > It first() const {
    769 //       It e; first(e); return e; }
    770 
    771 //     template< typename It > It first(const Node& v) const {
    772 //       It e; first(e, v); return e; }
    773 
    774 //     Node head(const Edge& e) const { return gw.head(e); }
    775 //     Node tail(const Edge& e) const { return gw.tail(e); }
    776 
    777 //     template<typename I> bool valid(const I& i) const
    778 //       { return gw.valid(i); }
    779  
    780 //     //template<typename I> void setInvalid(const I &i);
    781 //     //{ return graph->setInvalid(i); }
    782 
    783 //     int nodeNum() const { return gw.nodeNum(); }
    784 //     int edgeNum() const { return gw.edgeNum(); }
    785  
    786 // //     template<typename I> Node aNode(const I& e) const {
    787 // //       return graph->aNode(e); }
    788 // //     template<typename I> Node bNode(const I& e) const {
    789 // //       return graph->bNode(e); }
    790  
    791 //     Node addNode() const { return gw.addNode(); }
    792 // // FIXME: ez igy nem jo, mert nem
    793 // //    Edge addEdge(const Node& tail, const Node& head) const {
    794 // //      return graph->addEdge(tail, head); }
    795  
    796 //     template<typename I> void erase(const I& i) const { gw.erase(i); }
    797  
    798 //     void clear() const { gw.clear(); }
    799    
    800 //     template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> {
    801 //     public:
    802 //       NodeMap(const UndirGraphWrapper<GraphWrapper>& _G) :
    803 //      GraphWrapper::NodeMap<T>(_G.gw) { }
    804 //       NodeMap(const UndirGraphWrapper<GraphWrapper>& _G, T a) :
    805 //      GraphWrapper::NodeMap<T>(_G.gw, a) { }
    806 //     };
    807 
    808 //     template<typename T> class EdgeMap : public GraphWrapper::EdgeMap<T> {
    809 //     public:
    810 //       EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G) :
    811 //      GraphWrapper::EdgeMap<T>(_G.gw) { }
    812 //       EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G, T a) :
    813 //      GraphWrapper::EdgeMap<T>(_G.gw, a) { }
    814 //     };
    815 //   };
    816 
    817622
    818623  template<typename Graph>
     
    956761
    957762//    template<typename I> I& next(I &i) const { graph->next(i); return i; }   
    958 //    template<typename I> I getNext(const I& i) const { return gw.getNext(i); }
    959 
    960763    template< typename It > It first() const {
    961764      It e; this->first(e); return e; }
     
    19741777//     }
    19751778   
    1976     //template<typename I> I getNext(const I& i) const {
    1977     //  return gw.getNext(i);
    1978     //}
    1979 
    1980 
    19811779    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
    19821780    OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i.e); return i; }
     
    20871885// //     }
    20881886   
    2089 //     //template<typename I> I getNext(const I& i) const {
    2090 //     //  return gw.getNext(i);
    2091 //     //}
    2092 
    2093 
    20941887//     NodeIt& next(NodeIt& i) const {
    20951888//       graph->next(i);
Note: See TracChangeset for help on using the changeset viewer.