lemon-main: lemon/bits/map_extender.h@134852d7fb0a

     1 /* -*- mode: C++; indent-tabs-mode: nil; -*-

     2  *

     3  * This file is a part of LEMON, a generic C++ optimization library.

     4  *

     5  * Copyright (C) 2003-2009

     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).

     8  *

     9  * Permission to use, modify and distribute this software is granted

    10  * provided that this copyright notice appears in all copies. For

    11  * precise terms see the accompanying LICENSE file.

    12  *

    13  * This software is provided "AS IS" with no warranty of any kind,

    14  * express or implied, and with no claim as to its suitability for any

    15  * purpose.

    16  *

    17  */

    19 #ifndef LEMON_BITS_MAP_EXTENDER_H

    20 #define LEMON_BITS_MAP_EXTENDER_H

    22 #include <iterator>

    24 #include <lemon/bits/traits.h>

    26 #include <lemon/concept_check.h>

    27 #include <lemon/concepts/maps.h>

    29 //\file

    30 //\brief Extenders for iterable maps.

    32 namespace lemon {

    34   // \ingroup graphbits

    35   //

    36   // \brief Extender for maps

    37   template <typename _Map>

    38   class MapExtender : public _Map {

    39     typedef _Map Parent;

    40     typedef typename Parent::GraphType GraphType;

    42   public:

    44     typedef MapExtender Map;

    45     typedef typename Parent::Key Item;

    47     typedef typename Parent::Key Key;

    48     typedef typename Parent::Value Value;

    49     typedef typename Parent::Reference Reference;

    50     typedef typename Parent::ConstReference ConstReference;

    52     typedef typename Parent::ReferenceMapTag ReferenceMapTag;

    54     class MapIt;

    55     class ConstMapIt;

    57     friend class MapIt;

    58     friend class ConstMapIt;

    60   public:

    62     MapExtender(const GraphType& graph)

    63       : Parent(graph) {}

    65     MapExtender(const GraphType& graph, const Value& value)

    66       : Parent(graph, value) {}

    68   private:

    69     MapExtender& operator=(const MapExtender& cmap) {

    70       return operator=<MapExtender>(cmap);

    71     }

    73     template <typename CMap>

    74     MapExtender& operator=(const CMap& cmap) {

    75       Parent::operator=(cmap);

    76       return *this;

    77     }

    79   public:

    80     class MapIt : public Item {

    81       typedef Item Parent;

    83     public:

    85       typedef typename Map::Value Value;

    87       MapIt() {}

    89       MapIt(Invalid i) : Parent(i) { }

    91       explicit MapIt(Map& _map) : map(_map) {

    92         map.notifier()->first(*this);

    93       }

    95       MapIt(const Map& _map, const Item& item)

    96         : Parent(item), map(_map) {}

    98       MapIt& operator++() {

    99         map.notifier()->next(*this);

   100         return *this;

   101       }

   103       typename MapTraits<Map>::ConstReturnValue operator*() const {

   104         return map[*this];

   105       }

   107       typename MapTraits<Map>::ReturnValue operator*() {

   108         return map[*this];

   109       }

   111       void set(const Value& value) {

   112         map.set(*this, value);

   113       }

   115     protected:

   116       Map& map;

   118     };

   120     class ConstMapIt : public Item {

   121       typedef Item Parent;

   123     public:

   125       typedef typename Map::Value Value;

   127       ConstMapIt() {}

   129       ConstMapIt(Invalid i) : Parent(i) { }

   131       explicit ConstMapIt(Map& _map) : map(_map) {

   132         map.notifier()->first(*this);

   133       }

   135       ConstMapIt(const Map& _map, const Item& item)

   136         : Parent(item), map(_map) {}

   138       ConstMapIt& operator++() {

   139         map.notifier()->next(*this);

   140         return *this;

   141       }

   143       typename MapTraits<Map>::ConstReturnValue operator*() const {

   144         return map[*this];

   145       }

   147     protected:

   148       const Map& map;

   149     };

   151     class ItemIt : public Item {

   152       typedef Item Parent;

   154     public:

   156       ItemIt() {}

   158       ItemIt(Invalid i) : Parent(i) { }

   160       explicit ItemIt(Map& _map) : map(_map) {

   161         map.notifier()->first(*this);

   162       }

   164       ItemIt(const Map& _map, const Item& item)

   165         : Parent(item), map(_map) {}

   167       ItemIt& operator++() {

   168         map.notifier()->next(*this);

   169         return *this;

   170       }

   172     protected:

   173       const Map& map;

   175     };

   176   };

   178   // \ingroup graphbits

   179   //

   180   // \brief Extender for maps which use a subset of the items.

   181   template <typename _Graph, typename _Map>

   182   class SubMapExtender : public _Map {

   183     typedef _Map Parent;

   184     typedef _Graph GraphType;

   186   public:

   188     typedef SubMapExtender Map;

   189     typedef typename Parent::Key Item;

   191     typedef typename Parent::Key Key;

   192     typedef typename Parent::Value Value;

   193     typedef typename Parent::Reference Reference;

   194     typedef typename Parent::ConstReference ConstReference;

   196     typedef typename Parent::ReferenceMapTag ReferenceMapTag;

   198     class MapIt;

   199     class ConstMapIt;

   201     friend class MapIt;

   202     friend class ConstMapIt;

   204   public:

   206     SubMapExtender(const GraphType& _graph)

   207       : Parent(_graph), graph(_graph) {}

   209     SubMapExtender(const GraphType& _graph, const Value& _value)

   210       : Parent(_graph, _value), graph(_graph) {}

   212   private:

   213     SubMapExtender& operator=(const SubMapExtender& cmap) {

   214       return operator=<MapExtender>(cmap);

   215     }

   217     template <typename CMap>

   218     SubMapExtender& operator=(const CMap& cmap) {

   219       checkConcept<concepts::ReadMap<Key, Value>, CMap>();

   220       Item it;

   221       for (graph.first(it); it != INVALID; graph.next(it)) {

   222         Parent::set(it, cmap[it]);

   223       }

   224       return *this;

   225     }

   227   public:

   228     class MapIt : public Item {

   229       typedef Item Parent;

   231     public:

   232       typedef typename Map::Value Value;

   234       MapIt() {}

   236       MapIt(Invalid i) : Parent(i) { }

   238       explicit MapIt(Map& _map) : map(_map) {

   239         map.graph.first(*this);

   240       }

   242       MapIt(const Map& _map, const Item& item)

   243         : Parent(item), map(_map) {}

   245       MapIt& operator++() {

   246         map.graph.next(*this);

   247         return *this;

   248       }

   250       typename MapTraits<Map>::ConstReturnValue operator*() const {

   251         return map[*this];

   252       }

   254       typename MapTraits<Map>::ReturnValue operator*() {

   255         return map[*this];

   256       }

   258       void set(const Value& value) {

   259         map.set(*this, value);

   260       }

   262     protected:

   263       Map& map;

   265     };

   267     class ConstMapIt : public Item {

   268       typedef Item Parent;

   270     public:

   272       typedef typename Map::Value Value;

   274       ConstMapIt() {}

   276       ConstMapIt(Invalid i) : Parent(i) { }

   278       explicit ConstMapIt(Map& _map) : map(_map) {

   279         map.graph.first(*this);

   280       }

   282       ConstMapIt(const Map& _map, const Item& item)

   283         : Parent(item), map(_map) {}

   285       ConstMapIt& operator++() {

   286         map.graph.next(*this);

   287         return *this;

   288       }

   290       typename MapTraits<Map>::ConstReturnValue operator*() const {

   291         return map[*this];

   292       }

   294     protected:

   295       const Map& map;

   296     };

   298     class ItemIt : public Item {

   299       typedef Item Parent;

   301     public:

   303       ItemIt() {}

   305       ItemIt(Invalid i) : Parent(i) { }

   307       explicit ItemIt(Map& _map) : map(_map) {

   308         map.graph.first(*this);

   309       }

   311       ItemIt(const Map& _map, const Item& item)

   312         : Parent(item), map(_map) {}

   314       ItemIt& operator++() {

   315         map.graph.next(*this);

   316         return *this;

   317       }

   319     protected:

   320       const Map& map;

   322     };

   324   private:

   326     const GraphType& graph;

   328   };

   330 }

   332 #endif

author	Peter Kovacs <kpeter@inf.elte.hu>
	Sat, 10 Oct 2009 08:18:46 +0200
changeset 755	134852d7fb0a
parent 617	4137ef9aacc6
child 802	994c7df296c9
permissions	-rw-r--r--