COIN-OR::LEMON - Graph Library

Ignore:
Timestamp:
08/23/04 13:06:00 (17 years ago)
Author:
marci
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1031
Message:

stGraphWrapper modifications

File:
1 edited

Legend:

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

    r762 r768  
    3131  template<typename Graph>
    3232  class BipartiteGraphWrapper : public GraphWrapper<Graph> {
    33   protected:
     33  public:
    3434    typedef IterableBoolMap< typename Graph::template NodeMap<int> >
    3535    SFalseTTrueMap;
     36  protected:
    3637    SFalseTTrueMap* s_false_t_true_map;
    3738
     
    4748    static const bool S_CLASS;
    4849    static const bool T_CLASS;
     50
     51    /// This method is to reach the iterable maps of the bipartite graph or
     52    /// bipartite graph wrapper.
     53    const SFalseTTrueMap& sFalseTTrueMap() const {
     54      return *s_false_t_true_map;
     55    }
    4956   
    5057    //bool S_CLASS;
     
    212219  template<typename Graph>
    213220  class BipartiteGraph : public BipartiteGraphWrapper<Graph> {
    214     typedef IterableBoolMap< typename Graph::template NodeMap<int> >
    215     SFalseTTrueMap;
     221//     typedef IterableBoolMap< typename Graph::template NodeMap<int> >
     222//     SFalseTTrueMap;
    216223    typedef BipartiteGraphWrapper<Graph> Parent;
    217224  protected:
    218225    Graph gr;
    219226    typename Graph::template NodeMap<int> bipartite_map;
    220     SFalseTTrueMap s_false_t_true_map;
     227    typename Parent::SFalseTTrueMap s_false_t_true_map;
    221228  public:
    222229    typedef typename Parent::Node Node;
     
    259266  };
    260267
    261 
     268  template<typename Graph, typename sIterableMap, typename tIterableMap>
     269  class stGraphWrapper;
     270
     271  /// Easier stuff for bipartite graphs.
    262272  template<typename Graph>
    263   class stGraphWrapper;
     273  class stBipartiteGraphWrapper : public
     274  stGraphWrapper<Graph, typename Graph::SFalseTTrueMap,
     275                 typename Graph::SFalseTTrueMap> {
     276  public:
     277    typedef stGraphWrapper<Graph, typename Graph::SFalseTTrueMap,
     278                           typename Graph::SFalseTTrueMap> Parent;
     279    stBipartiteGraphWrapper(Graph& _graph) :
     280      Parent(_graph, _graph.sFalseTTrueMap(), _graph.sFalseTTrueMap()) { }
     281  };
    264282
    265283//   template<typename Graph>
     
    288306  ///
    289307  /// \author Marton Makai
    290   template<typename Graph>
     308  template<typename Graph, typename sIterableMap, typename tIterableMap>
    291309  class stGraphWrapper : public GraphWrapper<Graph> {
     310  protected:   
     311    const sIterableMap* s_iterable_map;
     312    const tIterableMap* t_iterable_map;
    292313  public:
    293314    class Node;
    294315    friend class Node;
    295316//GN, int
    296 //0 normalis, 1 s, 2, true, ez az iteralasi sorrend,
     317//0 normalis, 1 s, 2 t, ez az iteralasi sorrend,
    297318//es a vege a false azaz (invalid, 3)   
    298319    class NodeIt;
     
    335356    static const bool T_CLASS=true;
    336357
    337     stGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) ,
    338                                     S_NODE(INVALID, 1),
    339                                     T_NODE(INVALID, 2) { }
     358    // \bug not too nice constructor.
     359    stGraphWrapper(Graph& _graph,
     360                   const sIterableMap& _s_iterable_map,
     361                   const tIterableMap& _t_iterable_map) :
     362      GraphWrapper<Graph>(_graph),
     363      s_iterable_map(&_s_iterable_map),
     364      t_iterable_map(&_t_iterable_map),
     365      S_NODE(INVALID, 1),
     366      T_NODE(INVALID, 2) { }
    340367
    341368   
     
    350377    protected:
    351378      friend class GraphWrapper<Graph>;
    352       friend class stGraphWrapper<Graph>;
     379      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
    353380      template <typename T> friend class NodeMap;
    354381      friend class Edge;
     
    381408    class NodeIt {
    382409      friend class GraphWrapper<Graph>;
    383       friend class stGraphWrapper<Graph>;
     410      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
    384411      typename Graph::NodeIt n;
    385412      int spec;
     
    389416        n(_n), spec(_spec) { }
    390417      NodeIt(const Invalid& i) : n(i), spec(3) { }
    391       NodeIt(const stGraphWrapper<Graph>& _G) : n(*(_G.graph)), spec(0) {
     418      NodeIt(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G)
     419        : n(*(_G.graph)), spec(0) {
    392420        if (!_G.graph->valid(n)) spec=1;
    393421      }
     
    397425    class Edge : public Graph::Edge {
    398426      friend class GraphWrapper<Graph>;
    399       friend class stGraphWrapper<Graph>;
     427      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
    400428      template <typename T> friend class EdgeMap;
    401429      int spec;
     
    430458    class OutEdgeIt {
    431459      friend class GraphWrapper<Graph>;
    432       friend class stGraphWrapper<Graph>;
     460      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
    433461      typename Graph::OutEdgeIt e;
    434462      int spec;
     
    441469      }
    442470      OutEdgeIt(const Invalid& i) : e(i), spec(3), n(i) { }
    443       OutEdgeIt(const stGraphWrapper<Graph>& _G, const Node& _n) {
     471      OutEdgeIt(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G,
     472                const Node& _n) {
    444473        switch (_n.spec) {
    445474          case 0 :
     
    474503    class InEdgeIt {
    475504      friend class GraphWrapper<Graph>;
    476       friend class stGraphWrapper<Graph>;
     505      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
    477506      typename Graph::InEdgeIt e;
    478507      int spec;
     
    485514      }
    486515      InEdgeIt(const Invalid& i) : e(i), spec(3), n(i) { }
    487       InEdgeIt(const stGraphWrapper<Graph>& _G, const Node& _n) {
     516      InEdgeIt(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G,
     517               const Node& _n) {
    488518        switch (_n.spec) {
    489519          case 0 :
     
    518548    class EdgeIt {
    519549      friend class GraphWrapper<Graph>;
    520       friend class stGraphWrapper<Graph>;
     550      friend class stGraphWrapper<Graph, sIterableMap, tIterableMap>;
    521551      typename Graph::EdgeIt e;
    522552      int spec;
     
    528558        e(_e), spec(_spec), n(_n) { }
    529559      EdgeIt(const Invalid& i) : e(i), spec(3), n(i) { }
    530       EdgeIt(const stGraphWrapper<Graph>& _G) :
     560      EdgeIt(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G) :
    531561        e(*(_G.graph)), spec(0), n(INVALID) {
    532562        if (!_G.graph->valid(e)) {
     
    719749      T s_value, t_value;
    720750    public:
    721       NodeMap(const stGraphWrapper<Graph>& _G) :  Parent(_G),
    722                                                   s_value(),
    723                                                   t_value() { }
    724       NodeMap(const stGraphWrapper<Graph>& _G, T a) : Parent(_G, a),
    725                                                       s_value(a),
    726                                                       t_value(a) { }
     751      NodeMap(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G) :
     752        Parent(_G),
     753        s_value(),
     754        t_value() { }
     755      NodeMap(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G, T a)
     756        : Parent(_G, a),
     757          s_value(a),
     758          t_value(a) { }
    727759      T operator[](const Node& n) const {
    728760        switch (n.spec) {
     
    754786    /// This class is to wrap a node-map of \c Graph and two variables
    755787    /// storing values for \c S_NODE and \c T_NODE to a node-map of
    756     /// stGraphWrapper<Graph>.
     788    /// stGraphWrapper<Graph, sIterableMap, tIterableMap>.
    757789    template<typename NM> class NodeMapWrapper {
    758790    public:
     
    798830      typename GraphWrapper<Graph>::template NodeMap<T> node_value;
    799831    public:
    800       EdgeMap(const stGraphWrapper<Graph>& _G) : Parent(_G),
    801                                                  node_value(_G) { }
    802       EdgeMap(const stGraphWrapper<Graph>& _G, T a) : Parent(_G, a),
    803                                                       node_value(_G, a) { }
     832      EdgeMap(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G)
     833        : Parent(_G),
     834          node_value(_G) { }
     835      EdgeMap(const stGraphWrapper<Graph, sIterableMap, tIterableMap>& _G, T a)
     836        : Parent(_G, a),
     837          node_value(_G, a) { }
    804838      T operator[](const Edge& e) const {
    805839        switch (e.spec) {
     
    830864
    831865    /// This class is to wrap an edge-map and a node-map of \c Graph
    832     /// to an edge-map of stGraphWrapper<Graph>.
     866    /// to an edge-map of stGraphWrapper<Graph, sIterableMap, tIterableMap>.
    833867    template<typename EM, typename NM>
    834868    class EdgeMapWrapper {
Note: See TracChangeset for help on using the changeset viewer.