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

equal deleted inserted replaced

-:bc2ce3903bee
+:7851c24d0a01
 /// Base class of maps.
 /// Base class of maps.
 /// It provides the necessary <tt>typedef</tt>s required by the map concept.
-template<typename K, typename T, typename _NeedCopy = False>
+template<typename K, typename T>
 class MapBase {
 public:
-/// \e
-typedef _NeedCopy NeedCopy;
 ///\e
 typedef K Key;
 ///\e
 typedef T Value;
 };
 /// Null map. (a.k.a. DoNothingMap)
 /// If you have to provide a map only for its type definitions,
 /// or if you have to provide a writable map, but
 /// data written to it will sent to <tt>/dev/null</tt>...
-template<typename K, typename T, typename NC = False>
+template<typename K, typename T>
-class NullMap : public MapBase<K, T, NC> {
+class NullMap : public MapBase<K, T> {
 public:
-typedef MapBase<K, T, NC> Parent;
+typedef MapBase<K, T> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 /// Gives back a default constructed element.
 T operator[](const K&) const { return T(); }
 /// Absorbs the value.
 void set(const K&, const T&) {}
 };
 template <typename K, typename V>
-NullMap<K, V, True> nullMap() {
+NullMap<K, V> nullMap() {
-return NullMap<K, V, True>();
+return NullMap<K, V>();
 }
 /// Constant map.
 /// This is a readable map which assigns a specified value to each key.
 /// In other aspects it is equivalent to the \ref NullMap.
 /// \todo set could be used to set the value.
-template<typename K, typename T, typename NC = False>
+template<typename K, typename T>
-class ConstMap : public MapBase<K, T, NC> {
+class ConstMap : public MapBase<K, T> {
 private:
 T v;
 public:
-typedef MapBase<K, T, NC> Parent;
+typedef MapBase<K, T> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 /// Default constructor
 ///Returns a \ref ConstMap class
 ///This function just returns a \ref ConstMap class.
 ///\relates ConstMap
 template<typename K, typename V>
-inline ConstMap<K, V, True> constMap(const V &v) {
+inline ConstMap<K, V> constMap(const V &v) {
-return ConstMap<K, V, True>(v);
+return ConstMap<K, V>(v);
 }
 //\todo to document later
 template<typename T, T v>
 struct Const { };
 //\todo to document later
-template<typename K, typename V, V v, typename NC>
+template<typename K, typename V, V v>
-class ConstMap<K, Const<V, v>, NC > : public MapBase<K, V, NC> {
+class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
 public:
-typedef MapBase<K, V, False> Parent;
+typedef MapBase<K, V> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ConstMap() { }
 V operator[](const K&) const { return v; }
 ///Returns a \ref ConstMap class
 ///This function just returns a \ref ConstMap class.
 ///\relates ConstMap
 template<typename K, typename V, V v>
-inline ConstMap<K, Const<V, v>, True> constMap() {
+inline ConstMap<K, Const<V, v> > constMap() {
-return ConstMap<K, Const<V, v>, True>();
+return ConstMap<K, Const<V, v> >();
 }
 /// \c std::map wrapper
 /// This is essentially a wrapper for \c std::map. With addition that
 /// \brief Identity mapping.
 ///
 /// This mapping gives back the given key as value without any
 /// modification.
-template <typename T, typename NC = False>
+template <typename T>
-class IdentityMap : public MapBase<T, T, NC> {
+class IdentityMap : public MapBase<T, T> {
 public:
-typedef MapBase<T, T, NC> Parent;
+typedef MapBase<T, T> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 const T& operator[](const T& t) const {
 return t;
 ///Returns an \ref IdentityMap class
 ///This function just returns an \ref IdentityMap class.
 ///\relates IdentityMap
 template<typename T>
-inline IdentityMap<T, True> identityMap() {
+inline IdentityMap<T> identityMap() {
-return IdentityMap<T, True>();
+return IdentityMap<T>();
 }
 ///Convert the \c Value of a map to another type.
 ///This \ref concept::ReadMap "read only map"
 ///converts the \c Value of a maps to type \c T.
 ///Its \c Key is inherited from \c M.
-template <typename M, typename T, typename NC = False>
+template <typename M, typename T>
-class ConvertMap : public MapBase<typename M::Key, T, NC> {
+class ConvertMap : public MapBase<typename M::Key, T> {
-typename SmartConstReference<M>::Type m;
+const M& m;
 public:
-typedef MapBase<typename M::Key, T, NC> Parent;
+typedef MapBase<typename M::Key, T> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 ///This function just returns an \ref ConvertMap class.
 ///\relates ConvertMap
 ///\todo The order of the template parameters are changed.
 template<typename T, typename M>
-inline ConvertMap<M, T, True> convertMap(const M &m) {
+inline ConvertMap<M, T> convertMap(const M &m) {
-return ConvertMap<M, T, True>(m);
+return ConvertMap<M, T>(m);
 }
 ///Sum of two maps
 ///This \ref concept::ReadMap "read only map" returns the sum of the two
 ///given maps. Its \c Key and \c Value will be inherited from \c M1.
 ///The \c Key and \c Value of M2 must be convertible to those of \c M1.
-template<typename M1, typename M2, typename NC = False>
+template<typename M1, typename M2>
-class AddMap : public MapBase<typename M1::Key, typename M1::Value, NC> {
+class AddMap : public MapBase<typename M1::Key, typename M1::Value> {
-typename SmartConstReference<M1>::Type m1;
+const M1& m1;
-typename SmartConstReference<M2>::Type m2;
+const M2& m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value, NC> Parent;
+typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
 ///\todo How to call these type of functions?
 ///
 ///\relates AddMap
 ///\todo Wrong scope in Doxygen when \c \\relates is used
 template<typename M1, typename M2>
-inline AddMap<M1, M2, True> addMap(const M1 &m1,const M2 &m2) {
+inline AddMap<M1, M2> addMap(const M1 &m1,const M2 &m2) {
-return AddMap<M1, M2, True>(m1,m2);
+return AddMap<M1, M2>(m1,m2);
 }
 ///Shift a map with a constant.
 ///This \ref concept::ReadMap "read only map" returns the sum of the
 ///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, typename NC = False>
+template<typename M, typename C = typename M::Value>
-class ShiftMap : public MapBase<typename M::Key, typename M::Value, NC> {
+class ShiftMap : public MapBase<typename M::Key, typename M::Value> {
-typename SmartConstReference<M>::Type m;
+const M& m;
 C v;
 public:
-typedef MapBase<typename M::Key, typename M::Value, NC> Parent;
+typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 ///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, True> shiftMap(const M &m,const C &v) {
+inline ShiftMap<M, C> shiftMap(const M &m,const C &v) {
-return ShiftMap<M, C, True>(m,v);
+return ShiftMap<M, C>(m,v);
 }
 ///Difference of two maps
 ///This \ref concept::ReadMap "read only map" returns the difference
 ///of the values of the two
 ///given maps. Its \c Key and \c Value will be inherited from \c M1.
 ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
-template<typename M1, typename M2, typename NC = False>
+template<typename M1, typename M2>
-class SubMap : public MapBase<typename M1::Key, typename M1::Value, NC> {
+class SubMap : public MapBase<typename M1::Key, typename M1::Value> {
-typename SmartConstReference<M1>::Type m1;
+const M1& m1;
-typename SmartConstReference<M2>::Type m2;
+const M2& m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value, NC> Parent;
+typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
 ///This function just returns a \ref SubMap class.
 ///
 ///\relates SubMap
 template<typename M1, typename M2>
-inline SubMap<M1, M2, True> subMap(const M1 &m1, const M2 &m2) {
+inline SubMap<M1, M2> subMap(const M1 &m1, const M2 &m2) {
-return SubMap<M1, M2, True>(m1, m2);
+return SubMap<M1, M2>(m1, m2);
 }
 ///Product of two maps
 ///This \ref concept::ReadMap "read only map" returns the product of the
 ///values of the two
 ///given
 ///maps. Its \c Key and \c Value will be inherited from \c M1.
 ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
-template<typename M1, typename M2, typename NC = False>
+template<typename M1, typename M2>
-class MulMap : public MapBase<typename M1::Key, typename M1::Value, NC> {
+class MulMap : public MapBase<typename M1::Key, typename M1::Value> {
-typename SmartConstReference<M1>::Type m1;
+const M1& m1;
-typename SmartConstReference<M2>::Type m2;
+const M2& m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value, NC> Parent;
+typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 MulMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
 ///Returns a \ref MulMap class
 ///This function just returns a \ref MulMap class.
 ///\relates MulMap
 template<typename M1, typename M2>
-inline MulMap<M1, M2, True> mulMap(const M1 &m1,const M2 &m2) {
+inline MulMap<M1, M2> mulMap(const M1 &m1,const M2 &m2) {
-return MulMap<M1, M2, True>(m1,m2);
+return MulMap<M1, M2>(m1,m2);
 }
 ///Scales a maps with a constant.
 ///This \ref concept::ReadMap "read only map" returns the value of the
 ///is equivalent with
 ///\code
 ///  ConstMap<X::Key, X::Value> c_tmp(v);
 ///  MulMap<X, ConstMap<X::Key, X::Value> > sc(x,v);
 ///\endcode
-template<typename M, typename C = typename M::Value, typename NC = False>
+template<typename M, typename C = typename M::Value>
-class ScaleMap : public MapBase<typename M::Key, typename M::Value, NC> {
+class ScaleMap : public MapBase<typename M::Key, typename M::Value> {
-typename SmartConstReference<M>::Type m;
+const M& m;
 C v;
 public:
-typedef MapBase<typename M::Key, typename M::Value, NC> Parent;
+typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 ///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, True> scaleMap(const M &m,const C &v) {
+inline ScaleMap<M, C> scaleMap(const M &m,const C &v) {
-return ScaleMap<M, C, True>(m,v);
+return ScaleMap<M, C>(m,v);
 }
 ///Quotient of two maps
 ///This \ref concept::ReadMap "read only map" returns the quotient of the
 ///values of the two
 ///given maps. Its \c Key and \c Value will be inherited from \c M1.
 ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
-template<typename M1, typename M2, typename NC = False>
+template<typename M1, typename M2>
-class DivMap : public MapBase<typename M1::Key, typename M1::Value, NC> {
+class DivMap : public MapBase<typename M1::Key, typename M1::Value> {
-typename SmartConstReference<M1>::Type m1;
+const M1& m1;
-typename SmartConstReference<M2>::Type m2;
+const M2& m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value, NC> Parent;
+typedef MapBase<typename M1::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 DivMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
 ///Returns a \ref DivMap class
 ///This function just returns a \ref DivMap class.
 ///\relates DivMap
 template<typename M1, typename M2>
-inline DivMap<M1, M2, True> divMap(const M1 &m1,const M2 &m2) {
+inline DivMap<M1, M2> divMap(const M1 &m1,const M2 &m2) {
-return DivMap<M1, M2, True>(m1,m2);
+return DivMap<M1, M2>(m1,m2);
 }
 ///Composition of two maps
 ///This \ref concept::ReadMap "read only map" returns the composition of
 ///Its \c Key is inherited from \c M2 and its \c Value is from
 ///\c M1.
 ///The \c M2::Value must be convertible to \c M1::Key.
 ///\todo Check the requirements.
-template <typename M1, typename M2, typename NC = False>
+template <typename M1, typename M2>
-class ComposeMap : public MapBase<typename M2::Key, typename M1::Value, NC> {
+class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
-typename SmartConstReference<M1>::Type m1;
+const M1& m1;
-typename SmartConstReference<M2>::Type m2;
+const M2& m2;
 public:
-typedef MapBase<typename M2::Key, typename M1::Value, NC> Parent;
+typedef MapBase<typename M2::Key, typename M1::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 ComposeMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
 ///This function just returns a \ref ComposeMap class.
 ///
 ///\relates ComposeMap
 template <typename M1, typename M2>
-inline ComposeMap<M1, M2, True> composeMap(const M1 &m1,const M2 &m2) {
+inline ComposeMap<M1, M2> composeMap(const M1 &m1,const M2 &m2) {
-return ComposeMap<M1, M2, True>(m1,m2);
+return ComposeMap<M1, M2>(m1,m2);
 }
 ///Combines of two maps using an STL (binary) functor.
 ///Combines of two maps using an STL (binary) functor.
 ///\todo Check the requirements.
 template<typename M1, typename M2, typename F,
 	   typename V = typename F::result_type,
 	   typename NC = False>
-class CombineMap : public MapBase<typename M1::Key, V, NC> {
+class CombineMap : public MapBase<typename M1::Key, V> {
-typename SmartConstReference<M1>::Type m1;
+const M1& m1;
-typename SmartConstReference<M2>::Type m2;
+const M2& m2;
 F f;
 public:
-typedef MapBase<typename M1::Key, V, NC> Parent;
+typedef MapBase<typename M1::Key, V> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 CombineMap(const M1 &_m1,const M2 &_m2,const F &_f)
 ///addMap(m1,m2)
 ///\endcode
 ///
 ///\relates CombineMap
 template<typename M1, typename M2, typename F, typename V>
-inline CombineMap<M1, M2, F, V, True>
+inline CombineMap<M1, M2, F, V>
 combineMap(const M1& m1,const M2& m2, const F& f) {
-return CombineMap<M1, M2, F, V, True>(m1,m2,f);
+return CombineMap<M1, M2, F, V>(m1,m2,f);
 }
 template<typename M1, typename M2, typename F>
-inline CombineMap<M1, M2, F, typename F::result_type, True>
+inline CombineMap<M1, M2, F, typename F::result_type>
 combineMap(const M1& m1, const M2& m2, const F& f) {
 return combineMap<M1, M2, F, typename F::result_type>(m1,m2,f);
 }
 template<typename M1, typename M2, typename K1, typename K2, typename V>
-inline CombineMap<M1, M2, V (*)(K1, K2), V, True>
+inline CombineMap<M1, M2, V (*)(K1, K2), V>
 combineMap(const M1 &m1, const M2 &m2, V (*f)(K1, K2)) {
 return combineMap<M1, M2, V (*)(K1, K2), V>(m1,m2,f);
 }
 ///Negative value of a map
 ///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, typename NC = False>
+template<typename M>
-class NegMap : public MapBase<typename M::Key, typename M::Value, NC> {
+class NegMap : public MapBase<typename M::Key, typename M::Value> {
-typename SmartConstReference<M>::Type m;
+const M& m;
 public:
-typedef MapBase<typename M::Key, typename M::Value, NC> Parent;
+typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 NegMap(const M &_m) : m(_m) {};
 ///Returns a \ref NegMap class
 ///This function just returns a \ref NegMap class.
 ///\relates NegMap
 template <typename M>
-inline NegMap<M, True> negMap(const M &m) {
+inline NegMap<M> negMap(const M &m) {
-return NegMap<M, True>(m);
+return NegMap<M>(m);
 }
 ///Absolute value of a map
 ///  template<> inline double t_abs<>(double n) {return fabs(n);}
 ///  template<> inline long double t_abs<>(long double n) {return fabsl(n);}
 ///\endcode
-template<typename M, typename NC = False>
+template<typename M>
-class AbsMap : public MapBase<typename M::Key, typename M::Value, NC> {
+class AbsMap : public MapBase<typename M::Key, typename M::Value> {
-typename SmartConstReference<M>::Type m;
+const M& m;
 public:
-typedef MapBase<typename M::Key, typename M::Value, NC> Parent;
+typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 AbsMap(const M &_m) : m(_m) {};
 ///Returns a \ref AbsMap class
 ///This function just returns a \ref AbsMap class.
 ///\relates AbsMap
 template<typename M>
-inline AbsMap<M, True> absMap(const M &m) {
+inline AbsMap<M> absMap(const M &m) {
-return AbsMap<M, True>(m);
+return AbsMap<M>(m);
 }
 ///Converts an STL style functor to a map
 ///This \ref concept::ReadMap "read only map" returns the value
 template<typename F,
 	   typename K = typename F::argument_type,
 	   typename V = typename F::result_type,
 	   typename NC = False>
-class FunctorMap : public MapBase<K, V, NC> {
+class FunctorMap : public MapBase<K, V> {
 F f;
 public:
-typedef MapBase<K, V, NC> Parent;
+typedef MapBase<K, V> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 FunctorMap(const F &_f) : f(_f) {}
 ///This function just returns a \ref FunctorMap class.
 ///
 ///The third template parameter isn't necessary to be given.
 ///\relates FunctorMap
 template<typename K, typename V, typename F> inline
-FunctorMap<F, K, V, True> functorMap(const F &f) {
+FunctorMap<F, K, V> functorMap(const F &f) {
-return FunctorMap<F, K, V, True>(f);
+return FunctorMap<F, K, V>(f);
 }
 template <typename F> inline
-FunctorMap<F, typename F::argument_type, typename F::result_type, True>
+FunctorMap<F, typename F::argument_type, typename F::result_type>
 functorMap(const F &f) {
 return FunctorMap<F, typename F::argument_type,
-typename F::result_type, True>(f);
+typename F::result_type>(f);
 }
 template <typename K, typename V> inline
-FunctorMap<V (*)(K), K, V, True> functorMap(V (*f)(K)) {
+FunctorMap<V (*)(K), K, V> functorMap(V (*f)(K)) {
-return FunctorMap<V (*)(K), K, V, True>(f);
+return FunctorMap<V (*)(K), K, V>(f);
 }
 ///Converts a map to an STL style (unary) functor
 ///
 ///For the sake of convenience it also works as
 ///a ususal \ref concept::ReadMap "readable map",
 ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
-template <typename M, typename NC = False>
+template <typename M>
-class MapFunctor : public MapBase<typename M::Key, typename M::Value, NC> {
+class MapFunctor : public MapBase<typename M::Key, typename M::Value> {
-typename SmartConstReference<M>::Type m;
+const M& m;
 public:
-typedef MapBase<typename M::Key, typename M::Value, NC> Parent;
+typedef MapBase<typename M::Key, typename M::Value> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///\e
 typedef typename M::Key argument_type;
 ///Returns a \ref MapFunctor class
 ///This function just returns a \ref MapFunctor class.
 ///\relates MapFunctor
 template<typename M>
-inline MapFunctor<M, True> mapFunctor(const M &m) {
+inline MapFunctor<M> mapFunctor(const M &m) {
-return MapFunctor<M, True>(m);
+return MapFunctor<M>(m);
 }
 ///Applies all map setting operations to two maps
 ///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, typename NC = False>
+template<typename  M1, typename M2>
-class ForkMap : public MapBase<typename M1::Key, typename M1::Value, NC> {
+class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
-typename SmartConstReference<M1>::Type m1;
+const M1& m1;
-typename SmartConstReference<M2>::Type m2;
+const M2& m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value, NC> Parent;
+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) {};
 ///\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, True> forkMap(const M1 &m1,const M2 &m2) {
+inline ForkMap<M1, M2> forkMap(const M1 &m1,const M2 &m2) {
-return ForkMap<M1, M2, True>(m1,m2);
+return ForkMap<M1, M2>(m1,m2);
 }
 /* ************* BOOL MAPS ******************* */
 ///logical negation of
 ///value returned by the
 ///given map. Its \c Key and will be inherited from \c M,
 ///its Value is <tt>bool</tt>.
-template <typename M, typename NC = False>
+template <typename M>
-class NotMap : public MapBase<typename M::Key, bool, NC> {
+class NotMap : public MapBase<typename M::Key, bool> {
-typename SmartConstReference<M>::Type m;
+const M& m;
 public:
-typedef MapBase<typename M::Key, bool, NC> Parent;
+typedef MapBase<typename M::Key, bool> Parent;
 typedef typename Parent::Key Key;
 typedef typename Parent::Value Value;
 ///Constructor
 NotMap(const M &_m) : m(_m) {};
 ///Returns a \ref NotMap class
 ///This function just returns a \ref NotMap class.
 ///\relates NotMap
 template <typename M>
-inline NotMap<M, True> notMap(const M &m) {
+inline NotMap<M> notMap(const M &m) {
-return NotMap<M, True>(m);
+return NotMap<M>(m);
 }
 /// @}
 }

changeset 1713	49d22d34d95f
parent 1695	e6f99fe1723f
child 1725	22752dd6c693