lemon-1.3: comparison lemon/maps.h

equal deleted inserted replaced

-:6a956b1b19fe
+:678500f790f8
 ///Map based on std::map
 ///This is essentially a wrapper for \c std::map with addition that
 ///you can specify a default value different from \c Value().
 template <typename K, typename T, typename Compare = std::less<K> >
-class StdMap {
+class StdMap : public MapBase<K, T> {
 template <typename K1, typename T1, typename C1>
 friend class StdMap;
 public:
+typedef MapBase<K, T> Parent;
+///\e
+typedef typename Parent::Key Key;
+///\e
+typedef typename Parent::Value Value;
+///\e
+typedef T& Reference;
+///\e
+typedef const T& ConstReference;
 typedef True ReferenceMapTag;
-///\e
-typedef K Key;
-///\e
-typedef T Value;
-///\e
-typedef T& Reference;
-///\e
-typedef const T& ConstReference;
 private:
 typedef std::map<K, T, Compare> Map;
 Value _value;
 _value = t;
 _map.clear();
 }
 };
+///Returns a \ref StdMap class
+///This function just returns a \ref StdMap class with specified
+///default value.
+///\relates StdMap
+template<typename K, typename V, typename Compare = std::less<K> >
+inline StdMap<K, V, Compare> stdMap(const V& value = V()) {
+return StdMap<K, V, Compare>(value);
+}
+///Returns a \ref StdMap class created from an appropriate std::map
+///This function just returns a \ref StdMap class created from an
+///appropriate std::map.
+///\relates StdMap
+template<typename K, typename V, typename Compare = std::less<K> >
+inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map,
+const V& value = V() ) {
+return StdMap<K, V, Compare>(map, value);
+}
 /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>
 ///
 /// The current map has the <tt>[0..size-1]</tt> keyset and the values
 /// are stored in a \c std::vector<T>  container. It can be used with
 /// some data structures, for example \c UnionFind, \c BinHeap, when
 /// the used items are small integer numbers.
 ///
 /// \todo Revise its name
 template <typename T>
-class IntegerMap {
+class IntegerMap : public MapBase<int, T> {
 template <typename T1>
 friend class IntegerMap;
 public:
+typedef MapBase<int, T> Parent;
+///\e
+typedef typename Parent::Key Key;
+///\e
+typedef typename Parent::Value Value;
+///\e
+typedef T& Reference;
+///\e
+typedef const T& ConstReference;
 typedef True ReferenceMapTag;
-///\e
-typedef int Key;
-///\e
-typedef T Value;
-///\e
-typedef T& Reference;
-///\e
-typedef const T& ConstReference;
 private:
 typedef std::vector<T> Vector;
 Vector _vector;
 void set(const Key &k, const T& t) {
 _vector[k] = t;
 }
 };
+///Returns an \ref IntegerMap class
+///This function just returns an \ref IntegerMap class.
+///\relates IntegerMap
+template<typename T>
+inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {
+return IntegerMap<T>(size, value);
+}
 /// @}
 /// \addtogroup map_adaptors
 /// @{
 ///Constructor
 SimpleMap(const M &_m) : m(_m) {};
 ///\e
 Value operator[](Key k) const {return m[k];}
 };
+///Returns a \ref SimpleMap class
+///This function just returns a \ref SimpleMap class.
+///\relates SimpleMap
+template<typename M>
+inline SimpleMap<M> simpleMap(const M &m) {
+return SimpleMap<M>(m);
+}
 ///Simple writable wrapping of a map
 ///This \ref concepts::WriteMap "write map" returns the simple
 ///wrapping of the given map. Sometimes the reference maps cannot be
 ///\e
 Value operator[](Key k) const {return m[k];}
 ///\e
 void set(Key k, const Value& c) { m.set(k, c); }
 };
+///Returns a \ref SimpleWriteMap class
+///This function just returns a \ref SimpleWriteMap class.
+///\relates SimpleWriteMap
+template<typename M>
+inline SimpleWriteMap<M> simpleWriteMap(M &m) {
+return SimpleWriteMap<M>(m);
+}
 ///Sum of two maps
 ///This \c concepts::ReadMap "read only map" returns the sum of the two
 ///given maps.

changeset 45	bc69cdfe171c
parent 43	17e76967c49f
child 46	b6dd98b57d71