lemon-0.x: comparison lemon/maps.h

equal deleted inserted replaced

-:059b58989a79
+:261948a3650f
 ///\param _m is the undelying map
 ///\param _v is the shift value
 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
 ///This function just returns an \ref ShiftMap class.
 ///\relates ShiftMap
 ///\todo A better name is required.
 template<typename M, typename C>
 inline ShiftMap<M, C> shiftMap(const M &m,const C &v) {
 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
 ///\param _m is the undelying map
 ///\param _v is the scaling value
 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
 ///This function just returns an \ref ScaleMap class.
 ///\relates ScaleMap
 ///\todo A better name is required.
 template<typename M, typename C>
 inline ScaleMap<M, C> scaleMap(const M &m,const C &v) {
 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
 ///Constructor
 NegMap(const M &_m) : m(_m) {};
 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.
 ///\relates NegMap
 template <typename M>
 inline NegMap<M> negMap(const M &m) {
 return NegMap<M>(m);
 }
+template <typename M>
+inline NegWriteMap<M> negMap(M &m) {
+return NegWriteMap<M>(m);
+}
 ///Absolute value of a map
 ///This \ref concept::ReadMap "read only map" returns the absolute value
 ///of the
 template<typename M>
 inline MapFunctor<M> mapFunctor(const M &m) {
 return MapFunctor<M>(m);
 }
+///Applies all map setting operations to two maps
+///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.
+template<typename  M1, typename M2>
+class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
+const M1& m1;
+const M2& m2;
+public:
+typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+typedef typename Parent::Key Key;
+typedef typename Parent::Value Value;
+///Constructor
+ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};
+Value operator[](Key k) const {return m1[k];}
+};
 ///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.
 ///
 ///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 ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
+class ForkWriteMap : public MapBase<typename M1::Key, typename M1::Value> {
-const M1& m1;
+M1& m1;
-const M2& m2;
+M2& m2;
 public:
 typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
-ForkMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
+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);}
+void set(Key k, const Value &v) {m1.set(k,v); m2.set(k,v);}
 };
 ///Returns an \ref ForkMap class
 ///This function just returns an \ref ForkMap class.
 ///\todo How to call these type of functions?
 ///
 ///\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 ******************* */
 /// Constructor
 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
 ///This function just returns a \ref NotMap class.
 ///\relates NotMap
 template <typename M>
 inline NotMap<M> notMap(const M &m) {
 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
 /// copies all the true setted keys to the given iterator.
 ///

changeset 2068	6936f130bba2
parent 1993	2115143eceea
child 2080	630a5e16dc12