src/work/alpar/emptygraph.h
changeset 174 44700ed9ffaa
parent 165 9b078bc3ce13
child 178 cd254eed75eb
equal deleted inserted replaced
13:b8eb5269f3ea 14:4fee7a2b9aa9
     1 // -*-mode: c++; -*-
     1 // -*- c++ -*-
       
     2 #ifndef EMPTYGRAPH_H
       
     3 #define EMPTYGRAPH_H
     2 
     4 
     3 #include <invalid.h>
     5 #include <invalid.h>
     4 
     6 
     5 /// The namespace of HugoLib
     7 /// The namespace of HugoLib
     6 namespace hugo {
     8 namespace hugo {
    32     public:
    34     public:
    33       /// @warning The default constructor sets the iterator
    35       /// @warning The default constructor sets the iterator
    34       /// to an undefined value.
    36       /// to an undefined value.
    35       Node() {}   //FIXME
    37       Node() {}   //FIXME
    36       /// Initialize the iterator to be invalid
    38       /// Initialize the iterator to be invalid
    37       Node(Invalid) {};
    39       Node(Invalid) {}
    38       //Node(const Node &) {} 
    40       //Node(const Node &) {} 
    39       bool operator==(Node n) const { return true; } //FIXME
    41       bool operator==(Node n) const { return true; } //FIXME
    40       bool operator!=(Node n) const { return true; } //FIXME
    42       bool operator!=(Node n) const { return true; } //FIXME
    41     };
    43     };
    42     
    44     
    45     public:
    47     public:
    46       /// @warning The default constructor sets the iterator
    48       /// @warning The default constructor sets the iterator
    47       /// to an undefined value.
    49       /// to an undefined value.
    48       NodeIt() {} //FIXME
    50       NodeIt() {} //FIXME
    49       /// Initialize the iterator to be invalid
    51       /// Initialize the iterator to be invalid
    50       NodeIt(Invalid) {};
    52       NodeIt(Invalid) {}
    51       /// Sets the iterator to the first node of \c G.
    53       /// Sets the iterator to the first node of \c G.
    52       NodeIt(const EmptyGraph &G) {}
    54       NodeIt(const EmptyGraph &G) {}
    53       NodeIt(const NodeIt &) {} //FIXME
    55       NodeIt(const NodeIt &) {} //FIXME
    54     };
    56     };
    55     
    57     
    59     public:
    61     public:
    60       /// @warning The default constructor sets the iterator
    62       /// @warning The default constructor sets the iterator
    61       /// to an undefined value.
    63       /// to an undefined value.
    62       Edge() {}   //FIXME
    64       Edge() {}   //FIXME
    63       /// Initialize the iterator to be invalid
    65       /// Initialize the iterator to be invalid
    64       Edge(Invalid) {};
    66       Edge(Invalid) {}
    65       //Edge(const Edge &) {} 
    67       //Edge(const Edge &) {} 
    66       bool operator==(Edge n) const { return true; } //FIXME
    68       bool operator==(Edge n) const { return true; } //FIXME
    67       bool operator!=(Edge n) const { return true; } //FIXME    
    69       bool operator!=(Edge n) const { return true; } //FIXME    
    68     };
    70     };
    69     
    71     
    73     public:
    75     public:
    74       /// @warning The default constructor sets the iterator
    76       /// @warning The default constructor sets the iterator
    75       /// to an undefined value.
    77       /// to an undefined value.
    76       OutEdgeIt() {}
    78       OutEdgeIt() {}
    77       /// Initialize the iterator to be invalid
    79       /// Initialize the iterator to be invalid
    78       OutEdgeIt(Invalid) {};
    80       OutEdgeIt(Invalid) {}
    79       /// This constructor sets the iterator to first outgoing edge.
    81       /// This constructor sets the iterator to first outgoing edge.
    80     
    82     
    81       /// This constructor set the iterator to the first outgoing edge of
    83       /// This constructor set the iterator to the first outgoing edge of
    82       /// node
    84       /// node
    83       ///@param n the node
    85       ///@param n the node
    89     public:
    91     public:
    90       /// @warning The default constructor sets the iterator
    92       /// @warning The default constructor sets the iterator
    91       /// to an undefined value.
    93       /// to an undefined value.
    92       InEdgeIt() {}
    94       InEdgeIt() {}
    93       /// Initialize the iterator to be invalid
    95       /// Initialize the iterator to be invalid
    94       InEdgeIt(Invalid) {};
    96       InEdgeIt(Invalid) {}
    95       InEdgeIt(const EmptyGraph &, Node) {}    
    97       InEdgeIt(const EmptyGraph &, Node) {}    
    96     };
    98     };
    97     //  class SymEdgeIt : public Edge {};
    99     //  class SymEdgeIt : public Edge {};
    98     class EdgeIt : public Edge {
   100     class EdgeIt : public Edge {
    99     public:
   101     public:
   100       /// @warning The default constructor sets the iterator
   102       /// @warning The default constructor sets the iterator
   101       /// to an undefined value.
   103       /// to an undefined value.
   102       EdgeIt() {}
   104       EdgeIt() {}
   103       /// Initialize the iterator to be invalid
   105       /// Initialize the iterator to be invalid
   104       EdgeIt(Invalid) {};
   106       EdgeIt(Invalid) {}
   105       EdgeIt(const EmptyGraph &) {}
   107       EdgeIt(const EmptyGraph &) {}
   106     };
   108     };
   107 
   109 
   108     /// First node of the graph.
   110     /// First node of the graph.
   109 
   111 
   147     //   Node bNode(InEdgeIt) const {}
   149     //   Node bNode(InEdgeIt) const {}
   148     //   Node bNode(OutEdgeIt) const {}
   150     //   Node bNode(OutEdgeIt) const {}
   149     //   Node bNode(SymEdgeIt) const {}
   151     //   Node bNode(SymEdgeIt) const {}
   150 
   152 
   151     /// Checks if a node iterator is valid
   153     /// Checks if a node iterator is valid
   152     bool valid(const Node) const { return true;};
   154     bool valid(const Node) const { return true;}
   153     /// Checks if an edge iterator is valid
   155     /// Checks if an edge iterator is valid
   154     bool valid(const Edge) const { return true;};
   156     bool valid(const Edge) const { return true;}
   155 
   157 
   156     ///Gives back the \e id of a node.
   158     ///Gives back the \e id of a node.
   157     int id(const Node) const { return 0;};
   159     int id(const Node) const { return 0;}
   158     ///Gives back the \e id of an edge.
   160     ///Gives back the \e id of an edge.
   159     int id(const Edge) const { return 0;};
   161     int id(const Edge) const { return 0;}
   160 
   162 
   161     //void setInvalid(Node &) const {};
   163     //void setInvalid(Node &) const {};
   162     //void setInvalid(Edge &) const {};
   164     //void setInvalid(Edge &) const {};
   163   
   165   
   164     Node addNode() { return INVALID;}
   166     Node addNode() { return INVALID;}
   170     void clear() {}
   172     void clear() {}
   171 
   173 
   172     int nodeNum() { return 0;}
   174     int nodeNum() { return 0;}
   173     int edgeNum() { return 0;}
   175     int edgeNum() { return 0;}
   174 
   176 
   175     EmptyGraph() {};
   177     EmptyGraph() {}
   176     EmptyGraph(const EmptyGraph &G) {};
   178     EmptyGraph(const EmptyGraph &G) {}
   177   
   179   
   178   
   180   
   179 
   181 
   180     ///Read/write map from the nodes to type \c T.
   182     ///Read/write map from the nodes to type \c T.
   181     template<class T> class NodeMap
   183     template<class T> class NodeMap
   215     };
   217     };
   216   };
   218   };
   217 
   219 
   218   // @}
   220   // @}
   219 
   221 
   220 };
   222 } //namespace hugo
   221 
   223 
   222 
   224 
   223 
   225 
   224 // class EmptyBipGraph : public EmptyGraph
   226 // class EmptyBipGraph : public EmptyGraph
   225 // {
   227 // {
   234 
   236 
   235 //   enum NodeClass { A = 0, B = 1 };
   237 //   enum NodeClass { A = 0, B = 1 };
   236 //   NodeClass getClass(Node n) {}
   238 //   NodeClass getClass(Node n) {}
   237 
   239 
   238 // }
   240 // }
       
   241 
       
   242 #endif // EMPTYGRAPH_H