1.1 --- a/src/lemon/maps.h	Tue Jan 11 17:16:29 2005 +0000
     1.2 +++ b/src/lemon/maps.h	Wed Jan 12 12:51:30 2005 +0000
     1.3 @@ -98,6 +98,17 @@
     1.4      ConstMap(const ConstMap<K,T1> &, const T &_v) : v(_v) {}
     1.5    };
     1.6  
     1.7 +  ///Returns a \ref ConstMap class
     1.8 +
     1.9 +  ///This function just returns a \ref ConstMap class.
    1.10 +  ///\relates ConstMap
    1.11 +  template<class V,class K> 
    1.12 +  inline ConstMap<V,K> constMap(const K &k) 
    1.13 +  {
    1.14 +    return ConstMap<V,K>(k);
    1.15 +  }
    1.16 +
    1.17 +
    1.18    //to document later
    1.19    template<typename T, T v>
    1.20    struct Const { };
    1.21 @@ -532,6 +543,89 @@
    1.22      return AbsMap<M>(m);
    1.23    }
    1.24  
    1.25 +  ///Converts an STL style functor to a a map
    1.26 +
    1.27 +  ///This \ref concept::ReadMap "read only map" returns the value
    1.28 +  ///of a
    1.29 +  ///given map.
    1.30 +  ///
    1.31 +  ///Template parameters \c K and \c V will become its
    1.32 +  ///\c Key and \c Value. They must be given explicitely
    1.33 +  ///because a functor does not provide such typedefs.
    1.34 +  ///
    1.35 +  ///Parameter \c F is the type of the used functor.
    1.36 +  
    1.37 +
    1.38 +  template<class K,class V,class F> 
    1.39 +  class FunctorMap
    1.40 +  {
    1.41 +    const F &f;
    1.42 +  public:
    1.43 +    typedef K Key;
    1.44 +    typedef V Value;
    1.45 +
    1.46 +    ///Constructor
    1.47 +
    1.48 +    ///\e
    1.49 +    ///
    1.50 +    FunctorMap(const F &_f) : f(_f) {};
    1.51 +    Value operator[](Key k) const {return f(k);}
    1.52 +  };
    1.53 +  
    1.54 +  ///Returns a \ref FunctorMap class
    1.55 +
    1.56 +  ///This function just returns a \ref FunctorMap class.
    1.57 +  ///
    1.58 +  ///The third template parameter isn't necessary to be given.
    1.59 +  ///\relates FunctorMap
    1.60 +  template<class K,class V, class F>
    1.61 +  inline FunctorMap<K,V,F> functorMap(const F &f) 
    1.62 +  {
    1.63 +    return FunctorMap<K,V,F>(f);
    1.64 +  }
    1.65 +
    1.66 +  ///Converts a map to an STL style functor
    1.67 +
    1.68 +  ///This class Converts a map to an STL style functor.
    1.69 +  ///that is it provides an <tt>operator()</tt> to read its values.
    1.70 +  ///
    1.71 +  ///For the sake of convenience it also works as a ususal map, i.e
    1.72 +  ///<tt>operator[]</tt> and the \c Key and \c Valu typedefs also exist.
    1.73 +
    1.74 +  template<class M> 
    1.75 +  class MapFunctor
    1.76 +  {
    1.77 +    const M &m;
    1.78 +  public:
    1.79 +    typedef typename M::Key Key;
    1.80 +    typedef typename M::Value Value;
    1.81 +
    1.82 +    ///Constructor
    1.83 +
    1.84 +    ///\e
    1.85 +    ///
    1.86 +    MapFunctor(const M &_m) : m(_m) {};
    1.87 +    ///Returns a value of the map
    1.88 +    
    1.89 +    ///\e
    1.90 +    ///
    1.91 +    Value operator()(Key k) const {return m[k];}
    1.92 +    ///\e
    1.93 +    ///
    1.94 +    Value operator[](Key k) const {return m[k];}
    1.95 +  };
    1.96 +  
    1.97 +  ///Returns a \ref MapFunctor class
    1.98 +
    1.99 +  ///This function just returns a \ref MapFunctor class.
   1.100 +  ///\relates MapFunctor
   1.101 +  template<class M> 
   1.102 +  inline MapFunctor<M> mapFunctor(const M &m) 
   1.103 +  {
   1.104 +    return MapFunctor<M>(m);
   1.105 +  }
   1.106 +
   1.107 +
   1.108    /// @}
   1.109    
   1.110  }