lemon-0.x: lemon/iterable_maps.h@98d83dd56c1d

     1 /* -*- C++ -*-

     2  * lemon/iterable_maps.h - Part of LEMON, a generic C++ optimization library

     3  *

     4  * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

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

     6  *

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

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

     9  * precise terms see the accompanying LICENSE file.

    10  *

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

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

    13  * purpose.

    14  *

    15  */

    17 #include <lemon/traits.h>

    18 #include <lemon/invalid.h>

    19 #include <vector>

    20 #include <limits>

    22 ///\ingroup maps

    23 ///\file

    24 ///\brief Maps that makes it possible to iterate through the keys having

    25 ///a certain value

    26 ///

    27 ///

    30 namespace lemon {

    32   ///\todo This is only a static map!

    33   ///\param BaseMap is an interger map.

    34   template<class BaseMap>

    35   class IterableBoolMap

    36   {

    37   public:

    39     typedef typename BaseMap::Key Key;

    40     typedef bool Value;

    42     friend class RefType;

    43     friend class FalseIt;

    44     friend class TrueIt;

    46   private:

    47     BaseMap &cref;

    48     std::vector<Key> vals;

    49     int sep;           //map[e] is true <=> cref[e]>=sep

    51     bool isTrue(Key k) {return cref[k]>=sep;}

    52     void swap(Key k, int s)

    53     {

    54       int ti=cref[k];

    55       Key tk=vals[s];

    56       cref[k]=s; vals[s]=k;

    57       cref[tk]=ti; vals[ti]=tk;

    58     }

    60     void setTrue(Key k) { if(cref[k]<sep) { sep--; swap(k,sep); } }

    61     void setFalse(Key k) { if(cref[k]>=sep) { swap(k,sep); sep++; } }

    63   public:

    64     ///\e

    65     void set(Key k,Value v) { if(v) setTrue(k); else setFalse(k);}

    67     ///\e

    68     class FalseIt

    69     {

    70       const IterableBoolMap &M;

    71       int i;

    72     public:

    73       explicit FalseIt(const IterableBoolMap &_M) : M(_M), i(0) { }

    74       FalseIt(Invalid)

    75 	: M(*((IterableBoolMap*)(0))), i(std::numeric_limits<int>::max()) { }

    76       FalseIt &operator++() { ++i; return *this;}

    77       operator Key() const { return i<M.sep ? M.vals[i] : INVALID; }

    78       bool operator !=(Invalid) const { return i<M.sep; }

    79       bool operator ==(Invalid) const { return i>=M.sep; }

    80     };

    81     ///\e

    82     class TrueIt

    83     {

    84       const IterableBoolMap &M;

    85       int i;

    86     public:

    87       explicit TrueIt(const IterableBoolMap &_M)

    88 	: M(_M), i(M.vals.size()-1) { }

    89       TrueIt(Invalid)

    90 	: M(*((IterableBoolMap*)(0))), i(-1) { }

    91       TrueIt &operator++() { --i; return *this;}

    92       operator Key() const { return i>=M.sep ? M.vals[i] : INVALID; }

    93       bool operator !=(Invalid) const { return i>=M.sep; }

    94       bool operator ==(Invalid) const { return i<M.sep; }

    95     };

    97     ///\e

    98     class RefType

    99     {

   100       IterableBoolMap &M;

   101       Key k;

   102     public:

   103       RefType(IterableBoolMap &_M,Key _k) : M(_M), k(_k) { }

   105       operator Value() const

   106       {

   107 	return M.isTrue(k);

   108       }

   109       Value operator = (Value v) const { M.set(k,v); return v; }

   110     };

   112   public:

   113     explicit IterableBoolMap(BaseMap &_m,bool init=false) : cref(_m)

   114     {

   115       sep=0;

   116       for(typename BaseMap::MapSet::iterator i=cref.mapSet().begin();

   117 	  i!=cref.mapSet().end();

   118 	  ++i) {

   119 	i->second=sep;

   120 	vals.push_back(i->first);

   121 	sep++;

   122       }

   123       if(init) sep=0;

   124     }

   125     RefType operator[] (Key k) { return RefType(*this,k);}

   126     Value operator[] (Key k) const { return isTrue(k);}

   127   };

   132   /// \addtogroup graph_maps

   133   /// @{

   135   /// Iterable bool NodeMap

   137   /// This map can be used in the same way

   138   /// as the standard NodeMap<bool> of the

   139   /// given graph \c Graph.

   140   /// In addition, this class provides two iterators called \ref TrueIt

   141   /// and \ref FalseIt to iterate through the "true" and "false" nodes.

   142   template <class Graph>

   143   class IterableBoolNodeMap

   144   {

   145     typename Graph::template NodeMap<int> cmap;

   147   public:

   149     typedef IterableBoolMap<typename Graph::template NodeMap<int> > BimType;

   150     BimType imap;

   153     typedef typename BimType::RefType RefType;

   154     typedef typename Graph::Node Key;

   155     typedef bool Value;

   157     friend class FalseIt;

   158     friend class TrueIt;

   160     ///\e

   161     IterableBoolNodeMap(const Graph &g,bool b=false) : cmap(g), imap(cmap,b) {}

   163   public:

   164     ///\e

   165     void set(Key k, bool v) { imap.set(k,v);}

   166 #ifdef DOXYGEN

   167     ///\e

   168     bool &operator[](Key k) { return imap[k];}

   169     ///\e

   170     const bool &operator[](Key k) const { return imap[k];}

   171 #else

   172     Value operator[](Key k) const { return imap[k];}

   173     RefType operator[](Key k) { return imap[k];}

   174 #endif

   175     ///Iterator for the "false" nodes

   176     class FalseIt : public BimType::FalseIt

   177     {

   178     public:

   179       explicit FalseIt(const IterableBoolNodeMap &m)

   180 	: BimType::FalseIt(m.imap) { }

   181       FalseIt(Invalid i) : BimType::FalseIt(i) { }

   182     };

   183     ///Iterator for the "true" nodes

   184     class TrueIt : public BimType::TrueIt

   185     {

   186     public:

   187       explicit TrueIt(const IterableBoolNodeMap &m)

   188 	: BimType::TrueIt(m.imap) { }

   189       TrueIt(Invalid i) : BimType::TrueIt(i) { }

   190     };

   191   };

   193   /// Iterable bool EdgeMap

   195   /// This map can be used in the same way

   196   /// as the standard EdgeMap<bool> of the

   197   /// given graph \c Graph.

   198   /// In addition, this class provides two iterators called \ref TrueIt

   199   /// and \ref FalseIt to iterate through the "true" and "false" edges.

   200   template <class Graph>

   201   class IterableBoolEdgeMap

   202   {

   203     typename Graph::template EdgeMap<int> cmap;

   205   public:

   207     typedef IterableBoolMap<typename Graph::template EdgeMap<int> > BimType;

   208     BimType imap;

   211     typedef typename BimType::RefType RefType;

   212     typedef typename Graph::Edge Key;

   213     typedef bool Value;

   215     friend class FalseIt;

   216     friend class TrueIt;

   218     ///\e

   219     IterableBoolEdgeMap(const Graph &g,bool b=false) : cmap(g), imap(cmap,b) {}

   221   public:

   222     ///\e

   223     void set(Key k, bool v) { imap.set(k,v);}

   224 #ifdef DOXYGEN

   225     ///\e

   226     bool &operator[](Key k) { return imap[k];}

   227     ///\e

   228     const bool &operator[](Key k) const { return imap[k];}

   229 #else

   230     Value operator[](Key k) const { return imap[k];}

   231     RefType operator[](Key k) { return imap[k];}

   232 #endif

   233     ///Iterator for the "false" edges

   234     class FalseIt : public BimType::FalseIt

   235     {

   236     public:

   237       explicit FalseIt(const IterableBoolEdgeMap &m)

   238 	: BimType::FalseIt(m.imap) { }

   239       FalseIt(Invalid i) : BimType::FalseIt(i) { }

   240     };

   241     ///Iterator for the "true" edges

   242     class TrueIt : public BimType::TrueIt

   243     {

   244     public:

   245       explicit TrueIt(const IterableBoolEdgeMap &m)

   246 	: BimType::TrueIt(m.imap) { }

   247       TrueIt(Invalid i) : BimType::TrueIt(i) { }

   248     };

   249   };

   252   namespace _iterable_maps_bits {

   253     template <typename Item>

   254     struct IterableIntMapNode {

   255       IterableIntMapNode() : value(-1) {}

   256       Item prev, next;

   257       int value;

   258     };

   259   }

   261   ///\ingroup maps

   262   ///

   263   /// \brief Dynamic iterable integer map.

   264   ///

   265   /// \todo Document please

   266   template <typename _Graph, typename _Item>

   267   class IterableIntMap : protected ItemSetTraits<_Graph, _Item>

   268   ::template Map<_iterable_maps_bits::IterableIntMapNode<_Item> >::Parent {

   269   public:

   270     typedef typename ItemSetTraits<_Graph, _Item>

   271     ::template Map<_iterable_maps_bits::IterableIntMapNode<_Item> >

   272     ::Parent Parent;

   274     typedef _Item Key;

   275     typedef int Value;

   276     typedef _Graph Graph;

   278     IterableIntMap(const Graph& graph) : Parent(graph) {}

   280   private:

   282     void unlace(const Key& key) {

   283       typename Parent::Value& node = Parent::operator[](key);

   284       if (node.value < 0) return;

   285       if (node.prev != INVALID) {

   286 	Parent::operator[](node.prev).next = node.next;

   287       } else {

   288 	first[node.value] = node.next;

   289       }

   290       if (node.next != INVALID) {

   291 	Parent::operator[](node.next).prev = node.prev;

   292       }

   293       while (!first.empty() && first.back() == INVALID) {

   294 	first.pop_back();

   295       }

   296     }

   298     void lace(const Key& key) {

   299       typename Parent::Value& node = Parent::operator[](key);

   300       if (node.value < 0) return;

   301       if (node.value >= (int)first.size()) {

   302 	first.resize(node.value + 1, INVALID);

   303       }

   304       node.prev = INVALID;

   305       node.next = first[node.value];

   306       if (node.next != INVALID) {

   307 	Parent::operator[](node.next).prev = key;

   308       }

   309       first[node.value] = key;

   310     }

   312   public:

   314     typedef True ReferenceMapTag;

   316     class Reference {

   317       friend class IterableIntMap;

   318     private:

   319       Reference(IterableIntMap& map, const Key& key)

   320 	: _key(key), _map(map) {}

   321     public:

   323       Reference& operator=(const Reference& value) {

   324 	_map.set(_key, (const int&)value);

   325  	return *this;

   326       }

   328       operator const int&() const {

   329 	return static_cast<const IterableIntMap&>(_map)[_key];

   330       }

   332       Reference& operator=(int value) {

   333 	_map.set(_key, value);

   334 	return *this;

   335       }

   336       Reference& operator+=(int value) {

   337 	_map.set(_key, _map[_key] + value);

   338 	return *this;

   339       }

   340       Reference& operator-=(int value) {

   341 	_map.set(_key, _map[_key] - value);

   342 	return *this;

   343       }

   344       Reference& operator*=(int value) {

   345 	_map.set(_key, _map[_key] * value);

   346 	return *this;

   347       }

   348       Reference& operator/=(int value) {

   349 	_map.set(_key, _map[_key] / value);

   350 	return *this;

   351       }

   352       Reference& operator%=(int value) {

   353 	_map.set(_key, _map[_key] % value);

   354 	return *this;

   355       }

   356       Reference& operator&=(int value) {

   357 	_map.set(_key, _map[_key] & value);

   358 	return *this;

   359       }

   360       Reference& operator|=(int value) {

   361 	_map.set(_key, _map[_key] | value);

   362 	return *this;

   363       }

   364       Reference& operator^=(int value) {

   365 	_map.set(_key, _map[_key] ^ value);

   366 	return *this;

   367       }

   368       Reference& operator<<=(int value) {

   369 	_map.set(_key, _map[_key] << value);

   370 	return *this;

   371       }

   372       Reference& operator>>=(int value) {

   373 	_map.set(_key, _map[_key] >> value);

   374 	return *this;

   375       }

   377     private:

   378       Key _key;

   379       IterableIntMap& _map;

   380     };

   382     typedef const Value& ConstReference;

   384     int size() const {

   385       return (int)first.size();

   386     }

   388     void set(const Key& key, const Value& value) {

   389       unlace(key);

   390       Parent::operator[](key).value = value;

   391       lace(key);

   392     }

   394     const Value& operator[](const Key& key) const {

   395       return Parent::operator[](key).value;

   396     }

   398     Reference operator[](const Key& key) {

   399       return Reference(*this, key);

   400     }

   402     class ItemIt : public _Item {

   403     public:

   404       typedef _Item Parent;

   406       ItemIt(Invalid) : Parent(INVALID), _map(0) {}

   408       ItemIt(const IterableIntMap& map, int value) : _map(&map) {

   409 	if (value < 0 || value >= (int)_map->first.size()) {

   410 	  Parent::operator=(INVALID);

   411 	} else {

   412 	  Parent::operator=(_map->first[value]);

   413 	}

   414       }

   416       ItemIt& operator++() {

   417 	Parent::operator=(_map->IterableIntMap::Parent::

   418 			  operator[](static_cast<Parent&>(*this)).next);

   419 	return *this;

   420       }

   423     private:

   424       const IterableIntMap* _map;

   425     };

   427   protected:

   429     virtual void erase(const Key& key) {

   430       unlace(key);

   431       Parent::erase(key);

   432     }

   434     virtual void clear() {

   435       first.clear();

   436       Parent::clear();

   437     }

   439   private:

   440     std::vector<_Item> first;

   441   };

   443   /// @}

   444 }

author	deba
	Wed, 02 Nov 2005 15:26:04 +0000
changeset 1753	98d83dd56c1d
parent 1685	5b37a10234bc
child 1759	0bb3fb3baffd
permissions	-rw-r--r--