# HG changeset patch
# User deba
# Date 1144080217 0
# Node ID 18c08f9129e461d924a9dc3206e86ad034b76d7b
# Parent  080d51024ac534b7f81c0fd5d417233e90b7cec9
Writeable extension of some maps

diff -r 080d51024ac5 -r 18c08f9129e4 lemon/maps.h
--- a/lemon/maps.h	Mon Apr 03 09:45:23 2006 +0000
+++ b/lemon/maps.h	Mon Apr 03 16:03:37 2006 +0000
@@ -351,6 +351,40 @@
     ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
     Value operator[](Key k) const {return m[k] + v;}
   };
+
+  ///Shift a map with a constant.
+
+  ///This \ref concept::ReadWriteMap "read-write map" returns the sum of the
+  ///given map and a constant value. It makes also possible to write the map.
+  ///Its \c Key and \c Value is inherited from \c M.
+  ///
+  ///Actually,
+  ///\code
+  ///  ShiftMap<X> sh(x,v);
+  ///\endcode
+  ///is equivalent with
+  ///\code
+  ///  ConstMap<X::Key, X::Value> c_tmp(v);
+  ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
+  ///\endcode
+  template<typename M, typename C = typename M::Value> 
+  class ShiftWriteMap : public MapBase<typename M::Key, typename M::Value> {
+    M& m;
+    C v;
+  public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+
+    ///Constructor
+
+    ///Constructor
+    ///\param _m is the undelying map
+    ///\param _v is the shift value
+    ShiftWriteMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
+    Value operator[](Key k) const {return m[k] + v;}
+    void set(Key k, const Value& c) { m.set(k, c - v); }
+  };
   
   ///Returns an \ref ShiftMap class
 
@@ -362,6 +396,11 @@
     return ShiftMap<M, C>(m,v);
   }
 
+  template<typename M, typename C> 
+  inline ShiftWriteMap<M, C> shiftMap(M &m,const C &v) {
+    return ShiftWriteMap<M, C>(m,v);
+  }
+
   ///Difference of two maps
 
   ///This \ref concept::ReadMap "read only map" returns the difference
@@ -456,6 +495,31 @@
     ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
     Value operator[](Key k) const {return v * m[k];}
   };
+
+  ///Scales a maps with a constant.
+
+  ///This \ref concept::ReadWriteMap "read-write map" returns the value of the
+  ///given map multiplied from the left side with a constant value. It can
+  ///be used as write map also if the given multiplier is not zero.
+  ///Its \c Key and \c Value is inherited from \c M.
+  template<typename M, typename C = typename M::Value> 
+  class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
+    M& m;
+    C v;
+  public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+
+    ///Constructor
+
+    ///Constructor
+    ///\param _m is the undelying map
+    ///\param _v is the scaling value
+    ScaleWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
+    Value operator[](Key k) const {return v * m[k];}
+    void set(Key k, const Value& c) { m.set(k, c / v);}
+  };
   
   ///Returns an \ref ScaleMap class
 
@@ -467,6 +531,11 @@
     return ScaleMap<M, C>(m,v);
   }
 
+  template<typename M, typename C> 
+  inline ScaleWriteMap<M, C> scaleMap(M &m,const C &v) {
+    return ScaleWriteMap<M, C>(m,v);
+  }
+
   ///Quotient of two maps
 
   ///This \ref concept::ReadMap "read only map" returns the quotient of the
@@ -635,6 +704,27 @@
     Value operator[](Key k) const {return -m[k];}
   };
   
+  ///Negative value of a map
+
+  ///This \ref concept::ReadWriteMap "read-write map" returns the negative
+  ///value of the value returned by the
+  ///given map. Its \c Key and \c Value will be inherited from \c M.
+  ///The unary \c - operator must be defined for \c Value, of course.
+
+  template<typename M> 
+  class NegWriteMap : public MapBase<typename M::Key, typename M::Value> {
+    M& m;
+  public:
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+
+    ///Constructor
+    NegWriteMap(M &_m) : m(_m) {};
+    Value operator[](Key k) const {return -m[k];}
+    void set(Key k, const Value& v) { m.set(k, -v); }
+  };
+
   ///Returns a \ref NegMap class
 
   ///This function just returns a \ref NegMap class.
@@ -644,6 +734,10 @@
     return NegMap<M>(m);
   }
 
+  template <typename M> 
+  inline NegWriteMap<M> negMap(M &m) {
+    return NegWriteMap<M>(m);
+  }
 
   ///Absolute value of a map
 
@@ -787,14 +881,11 @@
     return MapFunctor<M>(m);
   }
 
-
   ///Applies all map setting operations to two maps
 
-  ///This map has two \ref concept::WriteMap "writable map"
-  ///parameters and each write request will be passed to both of them.
-  ///If \c M1 is also \ref concept::ReadMap "readable",
-  ///then the read operations will return the
-  ///corresponding values of \c M1.
+  ///This map has two \ref concept::ReadMap "readable map"
+  ///parameters and each read request will be passed just to the
+  ///first map. This class is the just readable map type of the ForkWriteMap.
   ///
   ///The \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
@@ -809,9 +900,35 @@
     typedef typename Parent::Value Value;
 
     ///Constructor
-    ForkMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+    ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};
     Value operator[](Key k) const {return m1[k];}
-    //    void set(Key k, const Value &v) {m1.set(k,v); m2.set(k,v);}
+  };
+
+
+  ///Applies all map setting operations to two maps
+
+  ///This map has two \ref concept::WriteMap "writable map"
+  ///parameters and each write request will be passed to both of them.
+  ///If \c M1 is also \ref concept::ReadMap "readable",
+  ///then the read operations will return the
+  ///corresponding values of \c M1.
+  ///
+  ///The \c Key and \c Value will be inherited from \c M1.
+  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
+
+  template<typename  M1, typename M2> 
+  class ForkWriteMap : public MapBase<typename M1::Key, typename M1::Value> {
+    M1& m1;
+    M2& m2;
+  public:
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+
+    ///Constructor
+    ForkWriteMap(M1 &_m1, M2 &_m2) : m1(_m1), m2(_m2) {};
+    Value operator[](Key k) const {return m1[k];}
+    void set(Key k, const Value &v) {m1.set(k,v); m2.set(k,v);}
   };
   
   ///Returns an \ref ForkMap class
@@ -822,10 +939,15 @@
   ///\relates ForkMap
   ///\todo Wrong scope in Doxygen when \c \\relates is used
   template <typename M1, typename M2> 
-  inline ForkMap<M1, M2> forkMap(const M1 &m1,const M2 &m2) {
+  inline ForkMap<M1, M2> forkMap(const M1 &m1, const M2 &m2) {
     return ForkMap<M1, M2>(m1,m2);
   }
 
+  template <typename M1, typename M2> 
+  inline ForkWriteMap<M1, M2> forkMap(M1 &m1, M2 &m2) {
+    return ForkWriteMap<M1, M2>(m1,m2);
+  }
+
 
   
   /* ************* BOOL MAPS ******************* */
@@ -850,6 +972,27 @@
     NotMap(const M &_m) : m(_m) {};
     Value operator[](Key k) const {return !m[k];}
   };
+
+  ///Logical 'not' of a map with writing possibility
+  
+  ///This bool \ref concept::ReadWriteMap "read-write map" returns the 
+  ///logical negation of value returned by the given map. It is setted
+  ///then the negation of the value be setted to the original map.
+  ///Its \c Key and will be inherited from \c M,
+  ///its Value is <tt>bool</tt>.
+  template <typename M> 
+  class NotWriteMap : public MapBase<typename M::Key, bool> {
+    M& m;
+  public:
+    typedef MapBase<typename M::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+
+    /// Constructor
+    NotWriteMap(M &_m) : m(_m) {};
+    Value operator[](Key k) const {return !m[k];}
+    void set(Key k, bool v) { m.set(k, !v); }
+  };
   
   ///Returns a \ref NotMap class
   
@@ -860,6 +1003,11 @@
     return NotMap<M>(m);
   }
 
+  template <typename M> 
+  inline NotWriteMap<M> notMap(M &m) {
+    return NotWriteMap<M>(m);
+  }
+
   /// \brief Writable bool map for store each true assigned elements.
   ///
   /// Writable bool map for store each true assigned elements. It will
diff -r 080d51024ac5 -r 18c08f9129e4 test/maps_test.cc
--- a/test/maps_test.cc	Mon Apr 03 09:45:23 2006 +0000
+++ b/test/maps_test.cc	Mon Apr 03 16:03:37 2006 +0000
@@ -16,6 +16,9 @@
  *
  */
 
+#include <deque>
+#include <set>
+
 #include <lemon/concept_check.h>
 #include <lemon/concept/maps.h>
 #include <lemon/maps.h>
@@ -26,6 +29,7 @@
 using namespace lemon::concept;
 
 struct A {};
+inline bool operator<(A, A) { return true; }
 struct B {};
 
 class F {
@@ -41,6 +45,10 @@
 int binc(int, B) {return 4;}
 
 typedef ReadMap<A,double> DoubleMap;
+typedef ReadWriteMap<A, double> WriteDoubleMap;
+
+typedef ReadMap<A,bool> BoolMap;
+typedef ReadWriteMap<A, bool> BoolWriteMap;
 
 int main()
 { // checking graph components
@@ -55,14 +63,30 @@
   checkConcept<ReadMap<A,double>, MulMap<DoubleMap,DoubleMap> >();
   checkConcept<ReadMap<A,double>, DivMap<DoubleMap,DoubleMap> >();
   checkConcept<ReadMap<A,double>, NegMap<DoubleMap> >();
+  checkConcept<ReadWriteMap<A,double>, NegWriteMap<WriteDoubleMap> >();
   checkConcept<ReadMap<A,double>, AbsMap<DoubleMap> >();
   checkConcept<ReadMap<A,double>, ShiftMap<DoubleMap> >();
+  checkConcept<ReadWriteMap<A,double>, ShiftWriteMap<WriteDoubleMap> >();
   checkConcept<ReadMap<A,double>, ScaleMap<DoubleMap> >();
+  checkConcept<ReadWriteMap<A,double>, ScaleWriteMap<WriteDoubleMap> >();
+  checkConcept<ReadMap<A,double>, ForkMap<DoubleMap, DoubleMap> >();
+  checkConcept<ReadWriteMap<A,double>, 
+    ForkWriteMap<WriteDoubleMap, WriteDoubleMap> >();
   
   checkConcept<ReadMap<B,double>, ComposeMap<DoubleMap,ReadMap<B,A> > >();
 
   checkConcept<ReadMap<A,B>, FunctorMap<F, A, B> >();
 
+  checkConcept<ReadMap<A, bool>, NotMap<BoolMap> >();
+  checkConcept<ReadWriteMap<A, bool>, NotWriteMap<BoolWriteMap> >();
+
+  checkConcept<WriteMap<A, bool>, StoreBoolMap<A*> >();
+  checkConcept<WriteMap<A, bool>, BackInserterBoolMap<std::deque<A> > >();
+  checkConcept<WriteMap<A, bool>, FrontInserterBoolMap<std::deque<A> > >();
+  checkConcept<WriteMap<A, bool>, InserterBoolMap<std::set<A> > >();
+  checkConcept<WriteMap<A, bool>, FillBoolMap<WriteMap<A, B> > >();
+  checkConcept<WriteMap<A, bool>, SettingOrderBoolMap<WriteMap<A, int> > >();
+
   int a;
   
   a=mapFunctor(constMap<A,int>(2))(A());