Changeset 1076:67a115cdade4 in lemon-0.x

Timestamp:

01/12/05 13:51:30 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1472

Message:

functor->map and map->functor converters added.

Location:

src

Files:

• lemon/maps.h (modified) (2 diffs)
• test/maps_test.cc (modified) (2 diffs)

src/lemon/maps.h

@@ -99 +99 @@
   };
 
+  ///Returns a \ref ConstMap class
+
+  ///This function just returns a \ref ConstMap class.
+  ///\relates ConstMap
+  template<class V,class K> 
+  inline ConstMap<V,K> constMap(const K &k) 
+  {
+    return ConstMap<V,K>(k);
+  }
+
+
   //to document later
   template<typename T, T v>
@@ -533 +544 @@
   }
 
+  ///Converts an STL style functor to a a map
+
+  ///This \ref concept::ReadMap "read only map" returns the value
+  ///of a
+  ///given map.
+  ///
+  ///Template parameters \c K and \c V will become its
+  ///\c Key and \c Value. They must be given explicitely
+  ///because a functor does not provide such typedefs.
+  ///
+  ///Parameter \c F is the type of the used functor.
+  
+
+  template<class K,class V,class F> 
+  class FunctorMap
+  {
+    const F &f;
+  public:
+    typedef K Key;
+    typedef V Value;
+
+    ///Constructor
+
+    ///\e
+    ///
+    FunctorMap(const F &_f) : f(_f) {};
+    Value operator[](Key k) const {return f(k);}
+  };
+  
+  ///Returns a \ref FunctorMap class
+
+  ///This function just returns a \ref FunctorMap class.
+  ///
+  ///The third template parameter isn't necessary to be given.
+  ///\relates FunctorMap
+  template<class K,class V, class F>
+  inline FunctorMap<K,V,F> functorMap(const F &f) 
+  {
+    return FunctorMap<K,V,F>(f);
+  }
+
+  ///Converts a map to an STL style functor
+
+  ///This class Converts a map to an STL style functor.
+  ///that is it provides an <tt>operator()</tt> to read its values.
+  ///
+  ///For the sake of convenience it also works as a ususal map, i.e
+  ///<tt>operator[]</tt> and the \c Key and \c Valu typedefs also exist.
+
+  template<class M> 
+  class MapFunctor
+  {
+    const M &m;
+  public:
+    typedef typename M::Key Key;
+    typedef typename M::Value Value;
+
+    ///Constructor
+
+    ///\e
+    ///
+    MapFunctor(const M &_m) : m(_m) {};
+    ///Returns a value of the map
+    
+    ///\e
+    ///
+    Value operator()(Key k) const {return m[k];}
+    ///\e
+    ///
+    Value operator[](Key k) const {return m[k];}
+  };
+  
+  ///Returns a \ref MapFunctor class
+
+  ///This function just returns a \ref MapFunctor class.
+  ///\relates MapFunctor
+  template<class M> 
+  inline MapFunctor<M> mapFunctor(const M &m) 
+  {
+    return MapFunctor<M>(m);
+  }
+
+
   /// @}
   

src/test/maps_test.cc

@@ -10 +10 @@
 struct A {};
 struct B {};
+class F
+{
+public:
+  B operator()(const A &a) const {return B();}
+};
+
+int func(A a) {return 3;}
 
 typedef ReadMap<A,double> DoubleMap;
@@ -32 +39 @@
   checkConcept<ReadMap<B,double>, ComposeMap<DoubleMap,ReadMap<B,A> > >();
 
+  checkConcept<ReadMap<A,B>, FunctorMap<A,B,F> >();
+
+  int a;
+  
+  a=mapFunctor(constMap<A,int>(2))(A());
+  check(a==2,"Something is wrong with mapFunctor");
+
+  B b;
+  b=functorMap<A,B>(F())[A()];
+
+  a=functorMap<A,int>(&func)[A()];
+  check(a==3,"Something is wrong with functorMap");
+
   std::cout << __FILE__ ": All tests passed.\n";