COIN-OR::LEMON - Graph Library

Changeset 45:bc69cdfe171c in lemon-1.0


Ignore:
Timestamp:
01/07/08 23:36:33 (12 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Added missing inheritances and map-creator functions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/maps.h

    r43 r45  
    164164  ///you can specify a default value different from \c Value().
    165165  template <typename K, typename T, typename Compare = std::less<K> >
    166   class StdMap {
     166  class StdMap : public MapBase<K, T> {
    167167    template <typename K1, typename T1, typename C1>
    168168    friend class StdMap;
    169169  public:
    170170
     171    typedef MapBase<K, T> Parent;
     172    ///\e
     173    typedef typename Parent::Key Key;
     174    ///\e
     175    typedef typename Parent::Value Value;
     176    ///\e
     177    typedef T& Reference;
     178    ///\e
     179    typedef const T& ConstReference;
     180
    171181    typedef True ReferenceMapTag;
    172     ///\e
    173     typedef K Key;
    174     ///\e
    175     typedef T Value;
    176     ///\e
    177     typedef T& Reference;
    178     ///\e
    179     typedef const T& ConstReference;
    180182
    181183  private:
     
    240242
    241243  };
     244 
     245  ///Returns a \ref StdMap class
     246
     247  ///This function just returns a \ref StdMap class with specified
     248  ///default value.
     249  ///\relates StdMap
     250  template<typename K, typename V, typename Compare = std::less<K> >
     251  inline StdMap<K, V, Compare> stdMap(const V& value = V()) {
     252    return StdMap<K, V, Compare>(value);
     253  }
     254
     255  ///Returns a \ref StdMap class created from an appropriate std::map
     256
     257  ///This function just returns a \ref StdMap class created from an
     258  ///appropriate std::map.
     259  ///\relates StdMap
     260  template<typename K, typename V, typename Compare = std::less<K> >
     261  inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map,
     262                                       const V& value = V() ) {
     263    return StdMap<K, V, Compare>(map, value);
     264  }
    242265
    243266  /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>
     
    250273  /// \todo Revise its name
    251274  template <typename T>
    252   class IntegerMap {
     275  class IntegerMap : public MapBase<int, T> {
    253276
    254277    template <typename T1>
     
    257280  public:
    258281
     282    typedef MapBase<int, T> Parent;
     283    ///\e
     284    typedef typename Parent::Key Key;
     285    ///\e
     286    typedef typename Parent::Value Value;
     287    ///\e
     288    typedef T& Reference;
     289    ///\e
     290    typedef const T& ConstReference;
     291
    259292    typedef True ReferenceMapTag;
    260     ///\e
    261     typedef int Key;
    262     ///\e
    263     typedef T Value;
    264     ///\e
    265     typedef T& Reference;
    266     ///\e
    267     typedef const T& ConstReference;
    268293
    269294  private:
     
    314339
    315340  };
     341 
     342  ///Returns an \ref IntegerMap class
     343
     344  ///This function just returns an \ref IntegerMap class.
     345  ///\relates IntegerMap
     346  template<typename T>
     347  inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {
     348    return IntegerMap<T>(size, value);
     349  }
    316350
    317351  /// @}
     
    406440    Value operator[](Key k) const {return m[k];}
    407441  };
     442 
     443  ///Returns a \ref SimpleMap class
     444
     445  ///This function just returns a \ref SimpleMap class.
     446  ///\relates SimpleMap
     447  template<typename M>
     448  inline SimpleMap<M> simpleMap(const M &m) {
     449    return SimpleMap<M>(m);
     450  }
    408451
    409452  ///Simple writable wrapping of a map
     
    433476    void set(Key k, const Value& c) { m.set(k, c); }
    434477  };
     478
     479  ///Returns a \ref SimpleWriteMap class
     480
     481  ///This function just returns a \ref SimpleWriteMap class.
     482  ///\relates SimpleWriteMap
     483  template<typename M>
     484  inline SimpleWriteMap<M> simpleWriteMap(M &m) {
     485    return SimpleWriteMap<M>(m);
     486  }
    435487
    436488  ///Sum of two maps
Note: See TracChangeset for help on using the changeset viewer.