COIN-OR::LEMON - Graph Library

Ticket #224: d5e4ef884f8f.patch

File d5e4ef884f8f.patch, 32.8 KB (added by Balazs Dezso, 9 years ago)

Static maps

  • lemon/adaptors.h

    # HG changeset patch
    # User Balazs Dezso <deba@inf.elte.hu>
    # Date 1259431002 -3600
    # Node ID d5e4ef884f8fecaa503fdb9d60b4ea03c779fac4
    # Parent  9cc6e98c487d3a14fe1db17001f3c4a47350dc80
    Static maps for graphs (#224)
    
    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/adaptors.h
    a b  
    114114    public:
    115115      explicit NodeMap(const Adaptor& adaptor)
    116116        : Parent(*adaptor._digraph) {}
    117       NodeMap(const Adaptor& adaptor, const V& value)
    118         : Parent(*adaptor._digraph, value) { }
     117      NodeMap(const Adaptor& adaptor, const V& value, bool dynamic = true)
     118        : Parent(*adaptor._digraph, value, dynamic) { }
    119119
    120120    private:
    121121      NodeMap& operator=(const NodeMap& cmap) {
     
    137137    public:
    138138      explicit ArcMap(const DigraphAdaptorBase<DGR>& adaptor)
    139139        : Parent(*adaptor._digraph) {}
    140       ArcMap(const DigraphAdaptorBase<DGR>& adaptor, const V& value)
    141         : Parent(*adaptor._digraph, value) {}
     140      ArcMap(const DigraphAdaptorBase<DGR>& adaptor, const V& value,
     141             bool dynamic = true)
     142        : Parent(*adaptor._digraph, value, dynamic) {}
    142143
    143144    private:
    144145      ArcMap& operator=(const ArcMap& cmap) {
     
    256257    public:
    257258      explicit NodeMap(const GraphAdaptorBase<GR>& adapter)
    258259        : Parent(*adapter._graph) {}
    259       NodeMap(const GraphAdaptorBase<GR>& adapter, const V& value)
    260         : Parent(*adapter._graph, value) {}
     260      NodeMap(const GraphAdaptorBase<GR>& adapter, const V& value,
     261              bool dynamic = true)
     262        : Parent(*adapter._graph, value, dynamic) {}
    261263
    262264    private:
    263265      NodeMap& operator=(const NodeMap& cmap) {
     
    279281    public:
    280282      explicit ArcMap(const GraphAdaptorBase<GR>& adapter)
    281283        : Parent(*adapter._graph) {}
    282       ArcMap(const GraphAdaptorBase<GR>& adapter, const V& value)
    283         : Parent(*adapter._graph, value) {}
     284      ArcMap(const GraphAdaptorBase<GR>& adapter, const V& value,
     285             bool dynamic = true)
     286        : Parent(*adapter._graph, value, dynamic) {}
    284287
    285288    private:
    286289      ArcMap& operator=(const ArcMap& cmap) {
     
    301304    public:
    302305      explicit EdgeMap(const GraphAdaptorBase<GR>& adapter)
    303306        : Parent(*adapter._graph) {}
    304       EdgeMap(const GraphAdaptorBase<GR>& adapter, const V& value)
    305         : Parent(*adapter._graph, value) {}
     307      EdgeMap(const GraphAdaptorBase<GR>& adapter, const V& value,
     308              bool dynamic = true)
     309        : Parent(*adapter._graph, value, dynamic) {}
    306310
    307311    private:
    308312      EdgeMap& operator=(const EdgeMap& cmap) {
     
    519523
    520524      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
    521525        : Parent(adaptor) {}
    522       NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
    523         : Parent(adaptor, value) {}
     526      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value,
     527              bool dynamic = true)
     528        : Parent(adaptor, value, dynamic) {}
    524529
    525530    private:
    526531      NodeMap& operator=(const NodeMap& cmap) {
     
    546551
    547552      ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
    548553        : Parent(adaptor) {}
    549       ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
    550         : Parent(adaptor, value) {}
     554      ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value,
     555             bool dynamic = true)
     556        : Parent(adaptor, value, dynamic) {}
    551557
    552558    private:
    553559      ArcMap& operator=(const ArcMap& cmap) {
     
    662668
    663669      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
    664670        : Parent(adaptor) {}
    665       NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
    666         : Parent(adaptor, value) {}
     671      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value,
     672              bool dynamic = true)
     673        : Parent(adaptor, value, dynamic) {}
    667674
    668675    private:
    669676      NodeMap& operator=(const NodeMap& cmap) {
     
    689696
    690697      ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
    691698        : Parent(adaptor) {}
    692       ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
    693         : Parent(adaptor, value) {}
     699      ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value,
     700             bool dynamic = true)
     701        : Parent(adaptor, value, dynamic) {}
    694702
    695703    private:
    696704      ArcMap& operator=(const ArcMap& cmap) {
     
    10321040
    10331041      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
    10341042        : Parent(adaptor) {}
    1035       NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
    1036         : Parent(adaptor, value) {}
     1043      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value,
     1044              bool dynamic = true)
     1045        : Parent(adaptor, value, dynamic) {}
    10371046
    10381047    private:
    10391048      NodeMap& operator=(const NodeMap& cmap) {
     
    10591068
    10601069      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
    10611070        : Parent(adaptor) {}
    1062       ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
    1063         : Parent(adaptor, value) {}
     1071      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value,
     1072             bool dynamic = true)
     1073        : Parent(adaptor, value, dynamic) {}
    10641074
    10651075    private:
    10661076      ArcMap& operator=(const ArcMap& cmap) {
     
    10871097      EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
    10881098        : Parent(adaptor) {}
    10891099
    1090       EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
    1091         : Parent(adaptor, value) {}
     1100      EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value,
     1101              bool dynamic = true)
     1102        : Parent(adaptor, value, dynamic) {}
    10921103
    10931104    private:
    10941105      EdgeMap& operator=(const EdgeMap& cmap) {
     
    12301241
    12311242      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
    12321243        : Parent(adaptor) {}
    1233       NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
    1234         : Parent(adaptor, value) {}
     1244      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value,
     1245              bool dynamic = true)
     1246        : Parent(adaptor, value, dynamic) {}
    12351247
    12361248    private:
    12371249      NodeMap& operator=(const NodeMap& cmap) {
     
    12571269
    12581270      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
    12591271        : Parent(adaptor) {}
    1260       ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
    1261         : Parent(adaptor, value) {}
     1272      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value,
     1273             bool dynamic = true)
     1274        : Parent(adaptor, value, dynamic) {}
    12621275
    12631276    private:
    12641277      ArcMap& operator=(const ArcMap& cmap) {
     
    12851298      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
    12861299        : Parent(adaptor) {}
    12871300
    1288       EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
    1289         : Parent(adaptor, value) {}
     1301      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value,
     1302              bool dynamic = true)
     1303        : Parent(adaptor, value, dynamic) {}
    12901304
    12911305    private:
    12921306      EdgeMap& operator=(const EdgeMap& cmap) {
     
    20972111      ArcMapBase(const UndirectorBase<DGR>& adaptor) :
    20982112        _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
    20992113
    2100       ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
    2101         : _forward(*adaptor._digraph, value),
    2102           _backward(*adaptor._digraph, value) {}
     2114      ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value,
     2115                 bool dynamic = true)
     2116        : _forward(*adaptor._digraph, value, dynamic),
     2117          _backward(*adaptor._digraph, value, dynamic) {}
     2118
     2119      void update() {
     2120        _forward.update();
     2121        _backward.update();
     2122      }
    21032123
    21042124      void set(const Arc& a, const V& value) {
    21052125        if (direction(a)) {
     
    21432163      explicit NodeMap(const UndirectorBase<DGR>& adaptor)
    21442164        : Parent(*adaptor._digraph) {}
    21452165
    2146       NodeMap(const UndirectorBase<DGR>& adaptor, const V& value)
    2147         : Parent(*adaptor._digraph, value) { }
     2166      NodeMap(const UndirectorBase<DGR>& adaptor, const V& value,
     2167              bool dynamic = true)
     2168        : Parent(*adaptor._digraph, value, dynamic) { }
    21482169
    21492170    private:
    21502171      NodeMap& operator=(const NodeMap& cmap) {
     
    21702191      explicit ArcMap(const UndirectorBase<DGR>& adaptor)
    21712192        : Parent(adaptor) {}
    21722193
    2173       ArcMap(const UndirectorBase<DGR>& adaptor, const V& value)
    2174         : Parent(adaptor, value) {}
     2194      ArcMap(const UndirectorBase<DGR>& adaptor, const V& value,
     2195             bool dynamic = true)
     2196        : Parent(adaptor, value, dynamic) {}
    21752197
    21762198    private:
    21772199      ArcMap& operator=(const ArcMap& cmap) {
     
    21952217      explicit EdgeMap(const UndirectorBase<DGR>& adaptor)
    21962218        : Parent(*adaptor._digraph) {}
    21972219
    2198       EdgeMap(const UndirectorBase<DGR>& adaptor, const V& value)
    2199         : Parent(*adaptor._digraph, value) {}
     2220      EdgeMap(const UndirectorBase<DGR>& adaptor, const V& value,
     2221              bool dynamic = true)
     2222        : Parent(*adaptor._digraph, value, dynamic) {}
    22002223
    22012224    private:
    22022225      EdgeMap& operator=(const EdgeMap& cmap) {
     
    24832506      explicit NodeMap(const OrienterBase<GR, DM>& adapter)
    24842507        : Parent(*adapter._graph) {}
    24852508
    2486       NodeMap(const OrienterBase<GR, DM>& adapter, const V& value)
    2487         : Parent(*adapter._graph, value) {}
     2509      NodeMap(const OrienterBase<GR, DM>& adapter, const V& value,
     2510              bool dynamic = true)
     2511        : Parent(*adapter._graph, value, dynamic) {}
    24882512
    24892513    private:
    24902514      NodeMap& operator=(const NodeMap& cmap) {
     
    25082532      explicit ArcMap(const OrienterBase<GR, DM>& adapter)
    25092533        : Parent(*adapter._graph) { }
    25102534
    2511       ArcMap(const OrienterBase<GR, DM>& adapter, const V& value)
    2512         : Parent(*adapter._graph, value) { }
     2535      ArcMap(const OrienterBase<GR, DM>& adapter, const V& value,
     2536             bool dynamic = true)
     2537        : Parent(*adapter._graph, value, dynamic) { }
    25132538
    25142539    private:
    25152540      ArcMap& operator=(const ArcMap& cmap) {
     
    31873212
    31883213      NodeMapBase(const SplitNodesBase<DGR>& adaptor)
    31893214        : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {}
    3190       NodeMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
    3191         : _in_map(*adaptor._digraph, value),
    3192           _out_map(*adaptor._digraph, value) {}
     3215      NodeMapBase(const SplitNodesBase<DGR>& adaptor, const V& value,
     3216                  bool dynamic = true)
     3217        : _in_map(*adaptor._digraph, value, dynamic),
     3218          _out_map(*adaptor._digraph, value, dynamic) {}
     3219
     3220      void update() {
     3221        _in_map.update();
     3222        _out_map.update();
     3223      }
    31933224
    31943225      void set(const Node& key, const V& val) {
    31953226        if (SplitNodesBase<DGR>::inNode(key)) { _in_map.set(key, val); }
     
    32263257
    32273258      ArcMapBase(const SplitNodesBase<DGR>& adaptor)
    32283259        : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {}
    3229       ArcMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
    3230         : _arc_map(*adaptor._digraph, value),
    3231           _node_map(*adaptor._digraph, value) {}
     3260      ArcMapBase(const SplitNodesBase<DGR>& adaptor, const V& value,
     3261                 bool dynamic = true)
     3262        : _arc_map(*adaptor._digraph, value, dynamic),
     3263          _node_map(*adaptor._digraph, value, dynamic) {}
     3264
     3265      void update() {
     3266        _arc_map.update();
     3267        _node_map.update();
     3268      }
    32323269
    32333270      void set(const Arc& key, const V& val) {
    32343271        if (SplitNodesBase<DGR>::origArc(key)) {
     
    32723309      NodeMap(const SplitNodesBase<DGR>& adaptor)
    32733310        : Parent(adaptor) {}
    32743311
    3275       NodeMap(const SplitNodesBase<DGR>& adaptor, const V& value)
    3276         : Parent(adaptor, value) {}
     3312      NodeMap(const SplitNodesBase<DGR>& adaptor, const V& value,
     3313              bool dynamic = true)
     3314        : Parent(adaptor, value, dynamic) {}
    32773315
    32783316    private:
    32793317      NodeMap& operator=(const NodeMap& cmap) {
     
    32983336      ArcMap(const SplitNodesBase<DGR>& adaptor)
    32993337        : Parent(adaptor) {}
    33003338
    3301       ArcMap(const SplitNodesBase<DGR>& adaptor, const V& value)
    3302         : Parent(adaptor, value) {}
     3339      ArcMap(const SplitNodesBase<DGR>& adaptor, const V& value,
     3340             bool dynamic = true)
     3341        : Parent(adaptor, value, dynamic) {}
    33033342
    33043343    private:
    33053344      ArcMap& operator=(const ArcMap& cmap) {
  • lemon/bits/alteration_notifier.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/bits/alteration_notifier.h
    a b  
    141141      // \brief Constructor which attach the observer into notifier.
    142142      //
    143143      // Constructor which attach the observer into notifier.
    144       ObserverBase(AlterationNotifier& nf) {
    145         attach(nf);
     144      ObserverBase(AlterationNotifier& nf, bool dynamic = true) {
     145        attach(nf, dynamic);
    146146      }
    147147
    148148      // \brief Constructor which attach the obserever to the same notifier.
    149149      //
    150150      // Constructor which attach the obserever to the same notifier as
    151151      // the other observer is attached to.
    152       ObserverBase(const ObserverBase& copy) {
     152      ObserverBase(const ObserverBase& copy, bool dynamic = true) {
    153153        if (copy.attached()) {
    154           attach(*copy.notifier());
     154          attach(*copy.notifier(), dynamic);
    155155        }
    156156      }
    157157
     
    165165      // \brief Attaches the observer into an AlterationNotifier.
    166166      //
    167167      // This member attaches the observer into an AlterationNotifier.
    168       void attach(AlterationNotifier& nf) {
    169         nf.attach(*this);
     168      void attach(AlterationNotifier& nf, bool dynamic = true) {
     169        nf.attach(*this, dynamic);
    170170      }
    171171
    172172      // \brief Detaches the observer into an AlterationNotifier.
     
    186186      // Gives back true when the observer is attached into a notifier.
    187187      bool attached() const { return _notifier != 0; }
    188188
     189      // Gives back true when the observer is dynamic.
     190      bool dynamic() const {
     191        return _notifier->_observers.end() != _index;
     192      }
     193
    189194    private:
    190195
    191196      ObserverBase& operator=(const ObserverBase& copy);
     
    331336
    332337  protected:
    333338
    334     void attach(ObserverBase& observer) {
    335       observer._index = _observers.insert(_observers.begin(), &observer);
     339    void attach(ObserverBase& observer, bool dynamic = true) {
     340      if (dynamic) {
     341        observer._index = _observers.insert(_observers.begin(), &observer);
     342      } else {
     343        observer._index = _observers.end();
     344      }
    336345      observer._notifier = this;
    337346    }
    338347
    339348    void detach(ObserverBase& observer) {
    340       _observers.erase(observer._index);
     349      if (observer._index != _observers.end()) {
     350        _observers.erase(observer._index);
     351      }
    341352      observer._index = _observers.end();
    342353      observer._notifier = 0;
    343354    }
  • lemon/bits/array_map.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/bits/array_map.h
    a b  
    8787      Notifier* nf = Parent::notifier();
    8888      Item it;
    8989      for (nf->first(it); it != INVALID; nf->next(it)) {
    90         int id = nf->id(it);;
     90        int id = nf->id(it);
    9191        allocator.construct(&(values[id]), Value());
    9292      }
    9393    }
     
    9595    // \brief Constructor to use default value to initialize the map.
    9696    //
    9797    // It constructs a map and initialize all of the the map.
    98     ArrayMap(const GraphType& graph, const Value& value) {
    99       Parent::attach(graph.notifier(Item()));
     98    ArrayMap(const GraphType& graph, const Value& value,
     99             bool dynamic = true) {
     100      Parent::attach(graph.notifier(Item()), dynamic);
    100101      allocate_memory();
    101       Notifier* nf = Parent::notifier();
    102       Item it;
    103       for (nf->first(it); it != INVALID; nf->next(it)) {
    104         int id = nf->id(it);;
    105         allocator.construct(&(values[id]), value);
     102      if (dynamic) {
     103        Notifier* nf = Parent::notifier();
     104        Item it;
     105        for (nf->first(it); it != INVALID; nf->next(it)) {
     106          int id = nf->id(it);
     107          allocator.construct(&(values[id]), value);
     108        }
     109      } else {
     110        for (int id = 0; id < capacity; ++id) {
     111          allocator.construct(&(values[id]), value);
     112        }
     113      }
     114    }
     115
     116    // \brief Updates the static map
     117    //
     118    // If the map is static map, this function reallocates the
     119    // capacity of the map to the current state of the item set.
     120    void update() {
     121      if (!Parent::dynamic()) {
     122        int max_id = Parent::notifier()->maxId();
     123        if (max_id >= capacity) {
     124          int new_capacity = (capacity == 0 ? 1 : capacity);
     125          while (new_capacity <= max_id) {
     126            new_capacity <<= 1;
     127          }
     128          Value* new_values = allocator.allocate(new_capacity);
     129          for (int id = 0; id < capacity; ++id) {
     130            allocator.construct(&(new_values[id]), values[id]);
     131          }
     132          for (int id = capacity; id < new_capacity; ++id) {
     133            allocator.construct(&(new_values[id]), Value());
     134          }
     135          if (capacity != 0) allocator.deallocate(values, capacity);
     136          values = new_values;
     137          capacity = new_capacity;
     138        }
    106139      }
    107140    }
    108141
     
    110143    // \brief Constructor to copy a map of the same map type.
    111144    //
    112145    // Constructor to copy a map of the same map type.
    113     ArrayMap(const ArrayMap& copy) : Parent() {
     146    ArrayMap(const ArrayMap& copy, bool dynamic = true) : Parent() {
    114147      if (copy.attached()) {
    115         attach(*copy.notifier());
     148        attach(*copy.notifier(), dynamic);
    116149      }
    117150      capacity = copy.capacity;
    118151      if (capacity == 0) return;
    119152      values = allocator.allocate(capacity);
    120       Notifier* nf = Parent::notifier();
    121       Item it;
    122       for (nf->first(it); it != INVALID; nf->next(it)) {
    123         int id = nf->id(it);;
    124         allocator.construct(&(values[id]), copy.values[id]);
     153      if (dynamic) {
     154        Notifier* nf = Parent::notifier();
     155        Item it;
     156        for (nf->first(it); it != INVALID; nf->next(it)) {
     157          int id = nf->id(it);
     158          allocator.construct(&(values[id]), copy.values[id]);
     159        }
     160      } else {
     161        std::vector<bool> constructed(capacity, false);
     162        Notifier* nf = Parent::notifier();
     163        Item it;
     164        for (nf->first(it); it != INVALID; nf->next(it)) {
     165          int id = nf->id(it);
     166          allocator.construct(&(values[id]), copy.values[id]);
     167          constructed[id] = true;
     168        }
     169        for (int id = 0; id < capacity; ++id) {
     170          if (!constructed[id]) {
     171            allocator.construct(&(values[id]), Value());
     172          }
     173        }
    125174      }
    126175    }
    127176
     
    160209    // The destructor of the map.
    161210    virtual ~ArrayMap() {
    162211      if (attached()) {
    163         clear();
     212        if (Parent::dynamic()) {
     213          Notifier* nf = Parent::notifier();
     214          if (capacity != 0) {
     215            Item it;
     216            for (nf->first(it); it != INVALID; nf->next(it)) {
     217              int id = nf->id(it);
     218              allocator.destroy(&(values[id]));
     219            }
     220            allocator.deallocate(values, capacity);
     221            capacity = 0;
     222          }
     223        } else {
     224          if (capacity != 0) {
     225            for (int id = 0; id < capacity; ++id) {
     226              allocator.destroy(&(values[id]));
     227            }
     228            allocator.deallocate(values, capacity);
     229            capacity = 0;
     230          }
     231        }
    164232        detach();
    165233      }
    166234    }
  • lemon/bits/default_map.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/bits/default_map.h
    a b  
    162162    typedef typename Parent::Value Value;
    163163
    164164    explicit DefaultMap(const GraphType& graph) : Parent(graph) {}
    165     DefaultMap(const GraphType& graph, const Value& value)
    166       : Parent(graph, value) {}
     165    DefaultMap(const GraphType& graph, const Value& value, bool dynamic = true)
     166      : Parent(graph, value, dynamic) {}
    167167
    168168    DefaultMap& operator=(const DefaultMap& cmap) {
    169169      return operator=<DefaultMap>(cmap);
  • lemon/bits/edge_set_extender.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/bits/edge_set_extender.h
    a b  
    224224    public:
    225225      explicit ArcMap(const Digraph& _g)
    226226        : Parent(_g) {}
    227       ArcMap(const Digraph& _g, const _Value& _v)
    228         : Parent(_g, _v) {}
     227      ArcMap(const Digraph& _g, const _Value& _v, bool dynamic = true)
     228        : Parent(_g, _v, dynamic) {}
    229229
    230230      ArcMap& operator=(const ArcMap& cmap) {
    231231        return operator=<ArcMap>(cmap);
     
    539539    public:
    540540      explicit ArcMap(const Graph& _g)
    541541        : Parent(_g) {}
    542       ArcMap(const Graph& _g, const _Value& _v)
    543         : Parent(_g, _v) {}
     542      ArcMap(const Graph& _g, const _Value& _v, bool dynamic = true)
     543        : Parent(_g, _v, dynamic) {}
    544544
    545545      ArcMap& operator=(const ArcMap& cmap) {
    546546        return operator=<ArcMap>(cmap);
     
    564564      explicit EdgeMap(const Graph& _g)
    565565        : Parent(_g) {}
    566566
    567       EdgeMap(const Graph& _g, const _Value& _v)
    568         : Parent(_g, _v) {}
     567      EdgeMap(const Graph& _g, const _Value& _v, bool dynamic = true)
     568        : Parent(_g, _v, dynamic) {}
    569569
    570570      EdgeMap& operator=(const EdgeMap& cmap) {
    571571        return operator=<EdgeMap>(cmap);
  • lemon/bits/graph_extender.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/bits/graph_extender.h
    a b  
    224224    public:
    225225      explicit NodeMap(const Digraph& digraph)
    226226        : Parent(digraph) {}
    227       NodeMap(const Digraph& digraph, const _Value& value)
    228         : Parent(digraph, value) {}
     227      NodeMap(const Digraph& digraph, const _Value& value, bool dynamic = true)
     228        : Parent(digraph, value, dynamic) {}
    229229
    230230    private:
    231231      NodeMap& operator=(const NodeMap& cmap) {
     
    248248    public:
    249249      explicit ArcMap(const Digraph& digraph)
    250250        : Parent(digraph) {}
    251       ArcMap(const Digraph& digraph, const _Value& value)
    252         : Parent(digraph, value) {}
     251      ArcMap(const Digraph& digraph, const _Value& value, bool dynamic = true)
     252        : Parent(digraph, value, dynamic) {}
    253253
    254254    private:
    255255      ArcMap& operator=(const ArcMap& cmap) {
     
    606606    public:
    607607      explicit NodeMap(const Graph& graph)
    608608        : Parent(graph) {}
    609       NodeMap(const Graph& graph, const _Value& value)
    610         : Parent(graph, value) {}
     609      NodeMap(const Graph& graph, const _Value& value, bool dynamic = true)
     610        : Parent(graph, value, dynamic) {}
    611611
    612612    private:
    613613      NodeMap& operator=(const NodeMap& cmap) {
     
    630630    public:
    631631      explicit ArcMap(const Graph& graph)
    632632        : Parent(graph) {}
    633       ArcMap(const Graph& graph, const _Value& value)
    634         : Parent(graph, value) {}
     633      ArcMap(const Graph& graph, const _Value& value, bool dynamic = true)
     634        : Parent(graph, value, dynamic = true) {}
    635635
    636636    private:
    637637      ArcMap& operator=(const ArcMap& cmap) {
     
    655655      explicit EdgeMap(const Graph& graph)
    656656        : Parent(graph) {}
    657657
    658       EdgeMap(const Graph& graph, const _Value& value)
    659         : Parent(graph, value) {}
     658      EdgeMap(const Graph& graph, const _Value& value, bool dynamic = true)
     659        : Parent(graph, value, dynamic) {}
    660660
    661661    private:
    662662      EdgeMap& operator=(const EdgeMap& cmap) {
  • lemon/bits/map_extender.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/bits/map_extender.h
    a b  
    6262    MapExtender(const GraphType& graph)
    6363      : Parent(graph) {}
    6464
    65     MapExtender(const GraphType& graph, const Value& value)
    66       : Parent(graph, value) {}
     65    MapExtender(const GraphType& graph, const Value& value, bool dynamic = true)
     66      : Parent(graph, value, dynamic) {}
    6767
    6868  private:
    6969    MapExtender& operator=(const MapExtender& cmap) {
     
    206206    SubMapExtender(const GraphType& _graph)
    207207      : Parent(_graph), graph(_graph) {}
    208208
    209     SubMapExtender(const GraphType& _graph, const Value& _value)
    210       : Parent(_graph, _value), graph(_graph) {}
     209    SubMapExtender(const GraphType& _graph, const Value& _value,
     210                   bool dynamic = true)
     211      : Parent(_graph, _value, dynamic), graph(_graph) {}
    211212
    212213  private:
    213214    SubMapExtender& operator=(const SubMapExtender& cmap) {
  • lemon/bits/vector_map.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/bits/vector_map.h
    a b  
    9898    //
    9999    // It constructs a map uses a given value to initialize the map.
    100100    // It adds all the items of the graph to the map.
    101     VectorMap(const GraphType& graph, const Value& value) {
    102       Parent::attach(graph.notifier(Item()));
     101    VectorMap(const GraphType& graph, const Value& value,
     102              bool dynamic = true) {
     103      Parent::attach(graph.notifier(Item()), dynamic);
    103104      container.resize(Parent::notifier()->maxId() + 1, value);
    104105    }
    105106
     107    // \brief Updates the static map
     108    //
     109    // If the map is static map, this function reallocates the
     110    // capacity of the map to the current state of the item set.
     111    void update() {
     112      if (!Parent::dynamic()) {
     113        container.resize(Parent::notifier()->maxId() + 1, Value());       
     114      }
     115    }
     116
    106117  private:
    107118    // \brief Copy constructor
    108119    //
    109120    // Copy constructor.
    110     VectorMap(const VectorMap& _copy) : Parent() {
     121    VectorMap(const VectorMap& _copy, bool dynamic = true) : Parent() {
    111122      if (_copy.attached()) {
    112         Parent::attach(*_copy.notifier());
     123        Parent::attach(*_copy.notifier(), dynamic);
    113124        container = _copy.container;
    114125      }
    115126    }
  • lemon/concepts/digraph.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/concepts/digraph.h
    a b  
    430430        /// Constructor
    431431        explicit NodeMap(const Digraph&) { }
    432432        /// Constructor with given initial value
    433         NodeMap(const Digraph&, T) { }
     433        NodeMap(const Digraph&, T, bool = true) { }
     434        /// Static map update
     435        void update() { }
    434436
    435437      private:
    436438        ///Copy constructor
     
    455457        /// Constructor
    456458        explicit ArcMap(const Digraph&) { }
    457459        /// Constructor with given initial value
    458         ArcMap(const Digraph&, T) { }
     460        ArcMap(const Digraph&, T, bool = true) { }
     461        /// Static map update
     462        void update() { }
    459463
    460464      private:
    461465        ///Copy constructor
  • lemon/concepts/graph.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/concepts/graph.h
    a b  
    517517        /// Constructor
    518518        explicit NodeMap(const Graph&) { }
    519519        /// Constructor with given initial value
    520         NodeMap(const Graph&, T) { }
     520        NodeMap(const Graph&, T, bool = true) { }
     521        /// Static map update
     522        void update() { }
    521523
    522524      private:
    523525        ///Copy constructor
     
    543545        /// Constructor
    544546        explicit ArcMap(const Graph&) { }
    545547        /// Constructor with given initial value
    546         ArcMap(const Graph&, T) { }
     548        ArcMap(const Graph&, T, bool = true) { }
     549        /// Static map update
     550        void update() { }
    547551
    548552      private:
    549553        ///Copy constructor
     
    569573        /// Constructor
    570574        explicit EdgeMap(const Graph&) { }
    571575        /// Constructor with given initial value
    572         EdgeMap(const Graph&, T) { }
     576        EdgeMap(const Graph&, T, bool = true) { }
     577        /// Static map update
     578        void update() { }
    573579
    574580      private:
    575581        ///Copy constructor
  • lemon/concepts/graph_components.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/concepts/graph_components.h
    a b  
    10181018      /// \brief Construct a new map with default value.
    10191019      ///
    10201020      /// Construct a new map for the graph and initalize the values.
    1021       GraphMap(const GR&, const Value&) {}
     1021      GraphMap(const GR&, const Value&, bool = true) {}
     1022      /// \brief Static map update
     1023      ///
     1024      /// Updates the static map
     1025      void update() {}
    10221026
    10231027    private:
    10241028      /// \brief Copy constructor.
     
    10451049            <ReferenceMap<Key, Value, Value&, const Value&>, _Map>();
    10461050          _Map m1(g);
    10471051          _Map m2(g,t);
     1052          _Map m3(g,t,false);
     1053
     1054          m3.update();
    10481055         
    10491056          // Copy constructor
    10501057          // _Map m3(m);
     
    10551062
    10561063          ignore_unused_variable_warning(m1);
    10571064          ignore_unused_variable_warning(m2);
     1065          ignore_unused_variable_warning(m3);
    10581066          // ignore_unused_variable_warning(m3);
    10591067        }
    10601068
     
    10991107        /// \brief Construct a new map with default value.
    11001108        ///
    11011109        /// Construct a new map for the digraph and initalize the values.
    1102         NodeMap(const MappableDigraphComponent& digraph, const V& value)
    1103           : Parent(digraph, value) {}
     1110        NodeMap(const MappableDigraphComponent& digraph, const V& value,
     1111                bool dynamic = true)
     1112          : Parent(digraph, value, dynamic) {}
    11041113
    11051114      private:
    11061115        /// \brief Copy constructor.
     
    11371146        /// \brief Construct a new map with default value.
    11381147        ///
    11391148        /// Construct a new map for the digraph and initalize the values.
    1140         ArcMap(const MappableDigraphComponent& digraph, const V& value)
    1141           : Parent(digraph, value) {}
     1149        ArcMap(const MappableDigraphComponent& digraph, const V& value,
     1150               bool dynamic = true)
     1151          : Parent(digraph, value, dynamic) {}
    11421152
    11431153      private:
    11441154        /// \brief Copy constructor.
     
    12351245        /// \brief Construct a new map with default value.
    12361246        ///
    12371247        /// Construct a new map for the graph and initalize the values.
    1238         EdgeMap(const MappableGraphComponent& graph, const V& value)
    1239           : Parent(graph, value) {}
     1248        EdgeMap(const MappableGraphComponent& graph, const V& value,
     1249                bool dynamic = true)
     1250          : Parent(graph, value, dynamic) {}
    12401251
    12411252      private:
    12421253        /// \brief Copy constructor.
  • lemon/dijkstra.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/dijkstra.h
    a b  
    125125    ///\ref PredMap.
    126126    static PredMap *createPredMap(const Digraph &g)
    127127    {
    128       return new PredMap(g);
     128      return new PredMap(g, INVALID, false);
    129129    }
    130130
    131131    ///The type of the map that indicates which nodes are processed.
     
    160160    ///the \ref DistMap.
    161161    static DistMap *createDistMap(const Digraph &g)
    162162    {
    163       return new DistMap(g);
     163      return new DistMap(g, 0, false);
    164164    }
    165165  };
    166166
  • lemon/edge_set.h

    diff -r 9cc6e98c487d -r d5e4ef884f8f lemon/edge_set.h
    a b  
    220220      explicit NodeMap(const ListArcSetBase<GR>& arcset)
    221221        : Parent(*arcset._graph) {}
    222222
    223       NodeMap(const ListArcSetBase<GR>& arcset, const V& value)
    224         : Parent(*arcset._graph, value) {}
     223      NodeMap(const ListArcSetBase<GR>& arcset, const V& value,
     224              bool dynamic = true)
     225        : Parent(*arcset._graph, value, dynamic) {}
    225226
    226227      NodeMap& operator=(const NodeMap& cmap) {
    227228        return operator=<NodeMap>(cmap);
     
    651652      explicit NodeMap(const ListEdgeSetBase<GR>& arcset)
    652653        : Parent(*arcset._graph) {}
    653654
    654       NodeMap(const ListEdgeSetBase<GR>& arcset, const V& value)
    655         : Parent(*arcset._graph, value) {}
     655      NodeMap(const ListEdgeSetBase<GR>& arcset, const V& value,
     656              bool dynamic = true)
     657        : Parent(*arcset._graph, value, dynamic) {}
    656658
    657659      NodeMap& operator=(const NodeMap& cmap) {
    658660        return operator=<NodeMap>(cmap);
     
    916918      explicit NodeMap(const SmartArcSetBase<GR>& arcset)
    917919        : Parent(*arcset._graph) { }
    918920
    919       NodeMap(const SmartArcSetBase<GR>& arcset, const V& value)
    920         : Parent(*arcset._graph, value) { }
     921      NodeMap(const SmartArcSetBase<GR>& arcset, const V& value,
     922              bool dynamic = true)
     923        : Parent(*arcset._graph, value, dynamic) { }
    921924
    922925      NodeMap& operator=(const NodeMap& cmap) {
    923926        return operator=<NodeMap>(cmap);
     
    12681271      explicit NodeMap(const SmartEdgeSetBase<GR>& arcset)
    12691272        : Parent(*arcset._graph) { }
    12701273
    1271       NodeMap(const SmartEdgeSetBase<GR>& arcset, const V& value)
    1272         : Parent(*arcset._graph, value) { }
     1274      NodeMap(const SmartEdgeSetBase<GR>& arcset, const V& value,
     1275              bool dynamic = true)
     1276        : Parent(*arcset._graph, value, dynamic) { }
    12731277
    12741278      NodeMap& operator=(const NodeMap& cmap) {
    12751279        return operator=<NodeMap>(cmap);