COIN-OR::LEMON - Graph Library

Changeset 1842:8abf74160dc4 in lemon-0.x for lemon/bits


Ignore:
Timestamp:
12/01/05 16:08:46 (14 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2396
Message:

NewEdgeSetAdaptor? -> ListEdgeSet?
and moved to edge_set.h

Location:
lemon/bits
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • lemon/bits/alteration_notifier.h

    r1832 r1842  
    399399  };
    400400
     401
     402  template <typename _Base>
     403  class AlterableEdgeSetExtender : public _Base {
     404  public:
     405
     406    typedef AlterableEdgeSetExtender Graph;
     407    typedef _Base Parent;
     408
     409    typedef typename Parent::Edge Edge;
     410
     411    /// The edge observer registry.
     412    typedef AlterationNotifier<Edge> EdgeNotifier;
     413
     414  protected:
     415
     416    mutable EdgeNotifier edge_notifier;
     417
     418  public:
     419
     420    /// \brief Gives back the edge alteration notifier.
     421    ///
     422    /// Gives back the edge alteration notifier.
     423    EdgeNotifier& getNotifier(Edge) const {
     424      return edge_notifier;
     425    }
     426
     427    ~AlterableEdgeSetExtender() {
     428      edge_notifier.clear();
     429    }
     430   
     431  };
     432
    401433  /// \brief Class to extend an undirected graph with the functionality of
    402434  /// alteration observing.
     
    438470    }
    439471  };
     472
     473  template <typename _Base>
     474  class AlterableUndirEdgeSetExtender
     475    : public AlterableEdgeSetExtender<_Base> {
     476  public:
     477
     478    typedef AlterableUndirEdgeSetExtender Graph;
     479    typedef AlterableEdgeSetExtender<_Base> Parent;
     480
     481    typedef typename Parent::UndirEdge UndirEdge;
     482
     483    typedef AlterationNotifier<UndirEdge> UndirEdgeNotifier;
     484
     485  protected:
     486
     487    mutable UndirEdgeNotifier undir_edge_notifier;
     488
     489  public:
     490
     491    using Parent::getNotifier;
     492    UndirEdgeNotifier& getNotifier(UndirEdge) const {
     493      return undir_edge_notifier;
     494    }
     495
     496    ~AlterableUndirEdgeSetExtender() {
     497      undir_edge_notifier.clear();
     498    }
     499  };
     500
    440501
    441502
  • lemon/bits/clearable_graph_extender.h

    r1820 r1842  
    2727
    2828  template <typename _Base>
     29  class ClearableEdgeSetExtender : public _Base {
     30  public:
     31
     32    typedef ClearableEdgeSetExtender Graph;
     33    typedef _Base Parent;
     34    typedef typename Parent::Node Node;
     35    typedef typename Parent::Edge Edge;
     36
     37    void clear() {
     38      Parent::getNotifier(Edge()).clear();
     39      Parent::clear();
     40    }
     41
     42  };
     43
     44  template <typename _Base>
    2945  class ClearableUndirGraphExtender : public _Base {
    3046  public:
     
    3854    void clear() {
    3955      Parent::getNotifier(Node()).clear();
     56      Parent::getNotifier(UndirEdge()).clear();
     57      Parent::getNotifier(Edge()).clear();
     58      Parent::clear();
     59    }
     60  };
     61
     62  template <typename _Base>
     63  class ClearableUndirEdgeSetExtender : public _Base {
     64  public:
     65
     66    typedef ClearableUndirEdgeSetExtender Graph;
     67    typedef _Base Parent;
     68    typedef typename Parent::Node Node;
     69    typedef typename Parent::UndirEdge UndirEdge;
     70    typedef typename Parent::Edge Edge;
     71
     72    void clear() {
    4073      Parent::getNotifier(UndirEdge()).clear();
    4174      Parent::getNotifier(Edge()).clear();
  • lemon/bits/default_map.h

    r1820 r1842  
    226226  /// \e
    227227  template <typename _Base>
     228  class MappableEdgeSetExtender : public _Base {
     229  public:
     230
     231    typedef MappableEdgeSetExtender<_Base> Graph;
     232    typedef _Base Parent;
     233
     234    typedef typename Parent::Edge Edge;
     235    typedef typename Parent::EdgeIt EdgeIt;
     236
     237    template <typename _Value>
     238    class EdgeMap
     239      : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
     240    public:
     241      typedef MappableEdgeSetExtender Graph;
     242      typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     243
     244      EdgeMap(const Graph& _g)
     245        : Parent(_g) {}
     246      EdgeMap(const Graph& _g, const _Value& _v)
     247        : Parent(_g, _v) {}
     248
     249      EdgeMap& operator=(const EdgeMap& cmap) {
     250        return operator=<EdgeMap>(cmap);
     251      }
     252
     253      template <typename CMap>
     254      EdgeMap& operator=(const CMap& cmap) {
     255        checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
     256        const typename Parent::Graph* graph = Parent::getGraph();
     257        Edge it;
     258        for (graph->first(it); it != INVALID; graph->next(it)) {
     259          Parent::set(it, cmap[it]);
     260        }
     261        return *this;
     262      }
     263    };
     264   
     265  };
     266
     267  /// \e
     268  template <typename _Base>
    228269  class MappableUndirGraphExtender :
    229270    public MappableGraphExtender<_Base> {
     
    240281    public:
    241282      typedef MappableUndirGraphExtender Graph;
     283      typedef IterableMapExtender<
     284        DefaultMap<Graph, UndirEdge, _Value> > Parent;
     285
     286      UndirEdgeMap(const Graph& _g)
     287        : Parent(_g) {}
     288      UndirEdgeMap(const Graph& _g, const _Value& _v)
     289        : Parent(_g, _v) {}
     290
     291      UndirEdgeMap& operator=(const UndirEdgeMap& cmap) {
     292        return operator=<UndirEdgeMap>(cmap);
     293      }
     294
     295      template <typename CMap>
     296      UndirEdgeMap& operator=(const CMap& cmap) {
     297        checkConcept<concept::ReadMap<UndirEdge, _Value>, CMap>();
     298        const typename Parent::Graph* graph = Parent::getGraph();
     299        UndirEdge it;
     300        for (graph->first(it); it != INVALID; graph->next(it)) {
     301          Parent::set(it, cmap[it]);
     302        }
     303        return *this;
     304      }
     305    };
     306
     307
     308  };
     309
     310  /// \e
     311  template <typename _Base>
     312  class MappableUndirEdgeSetExtender :
     313    public MappableEdgeSetExtender<_Base> {
     314  public:
     315
     316    typedef MappableUndirEdgeSetExtender Graph;
     317    typedef MappableEdgeSetExtender<_Base> Parent;
     318
     319    typedef typename Parent::UndirEdge UndirEdge;
     320
     321    template <typename _Value>
     322    class UndirEdgeMap
     323      : public IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> > {
     324    public:
     325      typedef MappableUndirEdgeSetExtender Graph;
    242326      typedef IterableMapExtender<
    243327        DefaultMap<Graph, UndirEdge, _Value> > Parent;
  • lemon/bits/erasable_graph_extender.h

    r1627 r1842  
    4747
    4848  template <typename _Base>
     49  class ErasableEdgeSetExtender : public _Base {
     50  public:
     51
     52    typedef ErasableEdgeSetExtender Graph;
     53    typedef _Base Parent;
     54
     55    typedef typename Parent::Edge Edge;
     56
     57    void erase(const Edge& edge) {
     58      Parent::getNotifier(Edge()).erase(edge);
     59      Parent::erase(edge);
     60    }
     61
     62  };
     63
     64  template <typename _Base>
    4965  class ErasableUndirGraphExtender : public _Base {
    5066  public:
     
    8096  };
    8197
     98  template <typename _Base>
     99  class ErasableUndirEdgeSetExtender : public _Base {
     100  public:
     101
     102    typedef ErasableUndirEdgeSetExtender Graph;
     103    typedef _Base Parent;
     104
     105    typedef typename Parent::Node Node;
     106    typedef typename Parent::UndirEdge UndirEdge;
     107    typedef typename Parent::Edge Edge;
     108
     109    void erase(const UndirEdge& uedge) {
     110      std::vector<Edge> edges;
     111      edges.push_back(Parent::direct(uedge,true));
     112      edges.push_back(Parent::direct(uedge,false));
     113      Parent::getNotifier(Edge()).erase(edges);
     114      Parent::getNotifier(UndirEdge()).erase(uedge);
     115      Parent::erase(uedge);
     116    }
     117
     118  };
     119
    82120}
    83121
  • lemon/bits/extendable_graph_extender.h

    r1820 r1842  
    3131
    3232  template <typename _Base>
     33  class ExtendableEdgeSetExtender : public _Base {
     34  public:
     35
     36    typedef ExtendableEdgeSetExtender Graph;
     37    typedef _Base Parent;
     38
     39    typedef typename Parent::Edge Edge;
     40    typedef typename Parent::Node Node;
     41
     42    Edge addEdge(const Node& from, const Node& to) {
     43      Edge edge = Parent::addEdge(from, to);
     44      Parent::getNotifier(Edge()).add(edge);
     45      return edge;
     46    }
     47
     48  };
     49
     50  template <typename _Base>
    3351  class ExtendableUndirGraphExtender : public _Base {
    3452  public:
     
    4664      return node;
    4765    }
     66
     67    UndirEdge addEdge(const Node& from, const Node& to) {
     68      UndirEdge uedge = Parent::addEdge(from, to);
     69      Parent::getNotifier(UndirEdge()).add(uedge);
     70
     71      std::vector<Edge> edges;
     72      edges.push_back(Parent::direct(uedge, true));
     73      edges.push_back(Parent::direct(uedge, false));
     74      Parent::getNotifier(Edge()).add(edges);
     75
     76      return uedge;
     77    }
     78
     79  };
     80
     81  template <typename _Base>
     82  class ExtendableUndirEdgeSetExtender : public _Base {
     83  public:
     84
     85    typedef ExtendableUndirEdgeSetExtender Graph;
     86    typedef _Base Parent;
     87
     88    typedef typename Parent::Node Node;
     89    typedef typename Parent::Edge Edge;
     90    typedef typename Parent::UndirEdge UndirEdge;
    4891
    4992    UndirEdge addEdge(const Node& from, const Node& to) {
Note: See TracChangeset for help on using the changeset viewer.