lemon-1.2: lemon/bits/map_extender.h@0747f332c478

     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     class MapIt;

    53     class ConstMapIt;

    55     friend class MapIt;

    56     friend class ConstMapIt;

    58   public:

    60     MapExtender(const GraphType& graph)

    61       : Parent(graph) {}

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

    64       : Parent(graph, value) {}

    66   private:

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

    68       return operator=<MapExtender>(cmap);

    69     }

    71     template <typename CMap>

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

    73       Parent::operator=(cmap);

    74       return *this;

    75     }

    77   public:

    78     class MapIt : public Item {

    79       typedef Item Parent;

    81     public:

    83       typedef typename Map::Value Value;

    85       MapIt() {}

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

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

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

    91       }

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

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

    96       MapIt& operator++() {

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

    98         return *this;

    99       }

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

   102         return map[*this];

   103       }

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

   106         return map[*this];

   107       }

   109       void set(const Value& value) {

   110         map.set(*this, value);

   111       }

   113     protected:

   114       Map& map;

   116     };

   118     class ConstMapIt : public Item {

   119       typedef Item Parent;

   121     public:

   123       typedef typename Map::Value Value;

   125       ConstMapIt() {}

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

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

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

   131       }

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

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

   136       ConstMapIt& operator++() {

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

   138         return *this;

   139       }

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

   142         return map[*this];

   143       }

   145     protected:

   146       const Map& map;

   147     };

   149     class ItemIt : public Item {

   150       typedef Item Parent;

   152     public:

   154       ItemIt() {}

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

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

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

   160       }

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

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

   165       ItemIt& operator++() {

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

   167         return *this;

   168       }

   170     protected:

   171       const Map& map;

   173     };

   174   };

   176   // \ingroup graphbits

   177   //

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

   179   template <typename _Graph, typename _Map>

   180   class SubMapExtender : public _Map {

   181     typedef _Map Parent;

   182     typedef _Graph GraphType;

   184   public:

   186     typedef SubMapExtender Map;

   187     typedef typename Parent::Key Item;

   189     typedef typename Parent::Key Key;

   190     typedef typename Parent::Value Value;

   191     typedef typename Parent::Reference Reference;

   192     typedef typename Parent::ConstReference ConstReference;

   194     class MapIt;

   195     class ConstMapIt;

   197     friend class MapIt;

   198     friend class ConstMapIt;

   200   public:

   202     SubMapExtender(const GraphType& _graph)

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

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

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

   208   private:

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

   210       return operator=<MapExtender>(cmap);

   211     }

   213     template <typename CMap>

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

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

   216       Item it;

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

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

   219       }

   220       return *this;

   221     }

   223   public:

   224     class MapIt : public Item {

   225       typedef Item Parent;

   227     public:

   228       typedef typename Map::Value Value;

   230       MapIt() {}

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

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

   235         map.graph.first(*this);

   236       }

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

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

   241       MapIt& operator++() {

   242         map.graph.next(*this);

   243         return *this;

   244       }

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

   247         return map[*this];

   248       }

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

   251         return map[*this];

   252       }

   254       void set(const Value& value) {

   255         map.set(*this, value);

   256       }

   258     protected:

   259       Map& map;

   261     };

   263     class ConstMapIt : public Item {

   264       typedef Item Parent;

   266     public:

   268       typedef typename Map::Value Value;

   270       ConstMapIt() {}

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

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

   275         map.graph.first(*this);

   276       }

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

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

   281       ConstMapIt& operator++() {

   282         map.graph.next(*this);

   283         return *this;

   284       }

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

   287         return map[*this];

   288       }

   290     protected:

   291       const Map& map;

   292     };

   294     class ItemIt : public Item {

   295       typedef Item Parent;

   297     public:

   299       ItemIt() {}

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

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

   304         map.graph.first(*this);

   305       }

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

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

   310       ItemIt& operator++() {

   311         map.graph.next(*this);

   312         return *this;

   313       }

   315     protected:

   316       const Map& map;

   318     };

   320   private:

   322     const GraphType& graph;

   324   };

   326 }

   328 #endif

author	Peter Kovacs <kpeter@inf.elte.hu>
	Wed, 08 Jul 2009 17:21:30 +0200
changeset 709	0747f332c478
parent 580	2313edd0db0b
child 718	703ebf476a1d
permissions	-rw-r--r--