January 2006 - Olena-patches

387: Static `if'.
by Roland Levillain 26 Jan '06

26 Jan '06

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Static `if'. * mlc/if.hh: New file. if.hh | 41 ++++++++++++++++++++++++++++++++--------- 1 file changed, 32 insertions(+), 9 deletions(-) Index: mlc/if.hh --- mlc/if.hh (revision 0) +++ mlc/if.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -31,8 +31,19 @@ # include <mlc/bool.hh> -/// Macro mlc_if. -# define mlc_if(Cond, Then, Else) typename mlc::if_<(Cond), (Then), (Else)>::ret +/** \def mlc_if(Cond, Then, Else) + ** \brief Static `if' on types. + ** + ** If \a Cond is true, evaluate to type \a Then, otherwise evaluate to + ** type \a Else. + ** + ** \note \a Then and \a Else must be valid types, since they are both + ** evaluated, whatever the result of \a Cond. + ** + */ +# define mlc_if(Cond, Then, Else) typename mlc::if_<Cond, Then, Else>::ret +/// Likewise, without the leading \c typename keyword. +# define mlc_if_(Cond, Then, Else) mlc::if_<Cond, Then, Else>::ret namespace mlc @@ -41,17 +52,23 @@ namespace internal { + /// \brief Declare a static `if'. + /// \note Internal class, don't use it directly. template <bool b, typename then_type, typename else_type> - struct fun_if_; + struct if_; + /// \brief Specialization of mlc::internal::if_ when condition is true. + /// \note Internal class, don't use it directly. template <typename then_type, typename else_type> - struct fun_if_ <true, then_type, else_type> + struct if_ <true, then_type, else_type> { typedef then_type ret; }; + /// \brief Specialization of mlc::internal::if_ when condition is false. + /// \note Internal class, don't use it directly. template <typename then_type, typename else_type> - struct fun_if_ <false, then_type, else_type> + struct if_ <false, then_type, else_type> { typedef else_type ret; }; @@ -59,14 +76,20 @@ } // end of namespace mlc::internal +/** \brief Static `if' on types. + ** + ** If \a Cond is true, evaluate to type \a Then, otherwise evaluate to + ** type \a Else. The \a ret member holds the result. + ** + ** \note \a Then and \a Else must be valid types, since they are both + ** evaluated, whatever the result of \a Cond. + */ template <typename cond_type, typename then_type, typename else_type> - struct if_ : public internal::fun_if_ < mlc_bool(cond_type), then_type, else_type > + struct if_ : public internal::if_ < mlc_bool(cond_type), then_type, else_type > { }; - } // end of namespace mlc - #endif // ! METALIC_IF_HH

1 0

386: Add mlc::ensure_ and update.
by Thierry GERAUD 26 Jan '06

26 Jan '06

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Add mlc::ensure_ and update. . * mlc/bool.hh: Update documentation. (internal::value_<bool,b>::ret): Rename as... (internal::value_<bool,b>::eval): ...this. (bool_<true>::ensure_t): Rename as... (bool_<true>::internal_ensure_): ...this. (internal::ensure_item<i,expr>): New class. (internal::none_): Relocate. (internal::none_::internal_ensure_): New typedef. (ensure_): New class. * mlc/value.hh (is_value, is_not_value): Move to... * mlc/cmp.hh (is_value, is_not_value): ...here. (eq_, neq_): Update static checks. bool.hh | 170 +++++++++++++++++++++++++++++++++++++++++++++------------------ cmp.hh | 22 ++++++-- value.hh | 25 +++++---- 3 files changed, 156 insertions(+), 61 deletions(-) Index: mlc/bool.hh --- mlc/bool.hh (revision 385) +++ mlc/bool.hh (working copy) @@ -115,7 +115,7 @@ */ static const bool value = b; - /*! \typedef ret + /*! \typedef eval ** ** Returns mlc::true_ or mlc::false_. ** @@ -127,11 +127,13 @@ ** Please note that, however, we usually do not need expression ** evaluation. The most common use of a Boolean expression is ** to check that it is verified (true) and, for that, we provide - ** ::ensure() and ::ensure_t. + ** "expr::ensure();" and "ensure_<expr..>". For instance: + ** or_<mlc_is_a(T, int), mlc_is_a(T, unsigned)>::ensure(); + ** ensures that T is int or unsigned without using ::eval. ** - ** \see mlc::true_ and mlc::false_ + ** \see mlc::true_, mlc::false_, mlc::ensure_<expr..>. */ - typedef bool_ ret; + typedef bool_ eval; private: @@ -146,9 +148,112 @@ template <typename T> friend class get_bool; }; + + /*! \class mlc::internal::ensure_item<i, expr> + ** + ** Internal so do not use it. This class is for use in the + ** definition of mlc::ensure_<..>. + ** + ** Design note: this class does not derive from abstract::type + ** because it is used in inheritance so a ctor should exist. + ** + ** \see mlc::ensure_<..> + */ + + template <unsigned i, typename expr> + struct ensure_item + { + }; + + + /*! \class mlc::internal::none_ + ** + ** Internal so do not use it. This class is for use in the + ** definition of mlc::ensure_<..>. + ** + ** Design notes: 1) This class does not derive from abstract::type + ** because it is used in inheritance so a ctor should exist. 2) + ** This class provides internal_ensure_ so that it acts like the + ** value 'true' in a sequence of 'and'; it thus has no effect when + ** appearing in an ensure_item. + ** + ** \see mlc::ensure_<..> + */ + + struct none_ + { + typedef none_ internal_ensure_; // provided such as in classes inheriting from true_ + }; + + } // end of namespace mlc::internal + + /*! \class mlc::ensure_<expr1..> + ** + ** This class is a replacement for a sequence of instructions: + ** "expr1::ensure(); .." when there is no room for having + ** instructions. The typical use is to express a constraint (or + ** several constraints) upon a parameter (or several parameters) + ** of a templated class. + ** + ** ensure_<..> has a variadic list of parameters. It expects at + ** least one parameter and handles up to 9 parameters. Each parameter + ** has to be a Boolean expression type. + ** + ** Sample uses: + ** + ** template <class T> + ** struct dummy : private ensure_< neq_<T, int> > + ** { ... + ** }; + ** means that T can be any type but int. + ** + ** template <class T1, class T2> + ** struct dummy2 : private ensure_< neq_<T1, int> >, + ** private ensure_< neq_<T2, int> > + ** { ... + ** }; + ** is equivalent to: + ** template <class T1, class T2> + ** struct dummy2 : private ensure_< neq_<T1, int>, + ** neq_<T2, int> > + ** { ... + ** }; + ** + ** Design notes: 1) This class does not derive from abstract::type + ** because it is used in inheritance so a ctor should exist. 2) + ** This class relies on mlc::internal::ensure_item to check that + ** each expression is true. + ** + */ + + template <typename expr_1, + typename expr_2 = internal::none_, + typename expr_3 = internal::none_, + typename expr_4 = internal::none_, + typename expr_5 = internal::none_, + typename expr_6 = internal::none_, + typename expr_7 = internal::none_, + typename expr_8 = internal::none_, + typename expr_9 = internal::none_> + struct ensure_ : + private internal::ensure_item<1, typename expr_1::internal_ensure_>, + private internal::ensure_item<2, typename expr_2::internal_ensure_>, + private internal::ensure_item<3, typename expr_3::internal_ensure_>, + private internal::ensure_item<4, typename expr_4::internal_ensure_>, + private internal::ensure_item<5, typename expr_5::internal_ensure_>, + private internal::ensure_item<6, typename expr_6::internal_ensure_>, + private internal::ensure_item<7, typename expr_7::internal_ensure_>, + private internal::ensure_item<8, typename expr_8::internal_ensure_>, + private internal::ensure_item<9, typename expr_9::internal_ensure_> + { + }; + + + + /*! \class mlc::bool_<true> ** ** Specialization of mlc::bool_ for b set to true. This type @@ -177,55 +282,29 @@ ** "Expr::ensure();" ** ** When there is no room in code for an instruction, use - ** ensure_t instead. + ** mlc::ensure_<expr1..> instead. ** ** Design note: This member is a no-op (it has no cost at ** run-time). + ** + ** \see: mlc::ensure<expr1..> */ static void ensure() {} - /*! \typedef ensure_t - ** - ** This typedef is inherited in every Boolean expression types that - ** derive from mlc::true_. This typedef is not provided in - ** mlc::false_. The type returned by this typedef has no meaning - ** (and thus no significant value). + /*! \typedef internal_ensure_ ** - ** A static check to ensure that a Boolean expression type, say - ** Expr, is verified can thus be written through the typedef - ** access: "Expr::ensure_t". This is a replacement for the - ** instruction "Expr::ensure();" when there is no room in code for - ** an instruction. + ** This is internal stuff so do not use it. ** - ** Sample use: - ** template <class T> - ** struct foo - ** : private mlc_is_a(T, base)::ensure_t - ** { - ** //... - ** }; - ** meaning that foo's parameter is constrainted to be a sub-class - ** of base. + ** This typedef is inherited in every Boolean expression types + ** that derive from mlc::true_. This typedef is not provided in + ** mlc::false_. The type returned by this typedef has no meaning + ** (and thus no significant value). A static check via + ** "mlc::ensure_<..>" uses this typedef. ** - ** Limitation: when using ensure_t to express several - ** constraints through private inheritance, such as in the sample - ** use above, one should express the set of constraints by a - ** single expression. The following code is not ok: - ** template <class T1, class T2> - ** struct foo - ** : private mlc_is_a(T1, base)::ensure_t, - ** private mlc_is_a(T2, base)::ensure_t - ** { ... }; - ** the problem being that we mulitply inherit from the same - ** class. The correct code should be written with a single - ** Boolean; practically the following code is ok: - ** template <class T1, class T2> - ** struct foo - ** : private mlc::and_<mlc_is_a(T1, base), - ** mlc_is_a(T2, base)>::ensure_t - ** { ... }; + ** \see mlc::internal::ensure_item<i, expr> */ - typedef struct{} ensure_t; + typedef internal::none_ internal_ensure_; + }; typedef bool_<true> true_; @@ -238,9 +317,9 @@ ** derive either from this type or from mlc::true_. ** ** Conversely to mlc::true_, this class does not feature ensure() - ** nor ensure_t. So, when a Boolean expression type, say Expr, + ** nor ensure_. So, when a Boolean expression type, say Expr, ** is evaluated to false, the static checks "Expr::ensure();" and - ** "Expr::ensure_t" do not compile. + ** "Expr::ensure_" do not compile. ** ** Design notes: 1) This specialization is defined so that mlc ** Booleans derive from mlc::abstract::boolean. 2) This @@ -321,7 +400,6 @@ namespace internal { - struct none_; // ors_2_ template <typename A1, typename A2> struct ors_2_ : public or_<A1, A2> {}; Index: mlc/value.hh --- mlc/value.hh (revision 385) +++ mlc/value.hh (working copy) @@ -162,22 +162,25 @@ # include <mlc/bool.hh> -# include <mlc/is_a.hh> -namespace mlc { +// FIXME: the following code causes inclusion recursion... - template <typename T> - struct is_value : public mlc_is_a(T, mlc::abstract::value) - { - }; +// # include <mlc/is_a.hh> - template <typename T> - struct is_not_value : public not_<mlc_is_a(T, mlc::abstract::value)> - { - }; +// namespace mlc { -} // end of namespace mlc +// template <typename T> +// struct is_value : public mlc_is_a(T, mlc::abstract::value) +// { +// }; + +// template <typename T> +// struct is_not_value : public not_<mlc_is_a(T, mlc::abstract::value)> +// { +// }; + +// } // end of namespace mlc #endif // ! METALIC_VALUE_HH Index: mlc/cmp.hh --- mlc/cmp.hh (revision 385) +++ mlc/cmp.hh (working copy) @@ -39,18 +39,31 @@ namespace mlc { + // FIXME: code moved from the end of value.hh + + template <typename T> + struct is_value : public mlc_is_a(T, mlc::abstract::value) + { + }; + + template <typename T> + struct is_not_value : public not_<mlc_is_a(T, mlc::abstract::value)> + { + }; + /// Equality test between a couple of types. template <typename T1, typename T2> - struct eq_ : private and_< is_not_value<T1>, is_not_value<T2> >::ensure_type, + struct eq_ : private ensure_< is_not_value<T1>, + is_not_value<T2> >, public false_ { }; template <typename T> - struct eq_ <T, T> : private is_not_value<T>::ensure_type, + struct eq_ <T, T> : private ensure_< is_not_value<T> >, public true_ { }; @@ -59,13 +72,14 @@ /// Inequality test between a couple of types. template <typename T1, typename T2> - struct neq_ : private and_< is_not_value<T1>, is_not_value<T2> >::ensure_type, + struct neq_ : private ensure_< is_not_value<T1>, + is_not_value<T2> >, public true_ { }; template <typename T> - struct neq_ <T, T> : private is_not_value<T>::ensure_type, + struct neq_ <T, T> : private ensure_< is_not_value<T> >, public false_ { };

1 0

385: Move Metalic-related entries in their own ChangeLog.
by Roland Levillain 25 Jan '06

25 Jan '06

https://svn.lrde.epita.fr/svn/oln/trunk Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Move Metalic-related entries in their own ChangeLog. * metalic/mlc: Move Metalic-related entries... * metalic/ChangeLog: ...here (new). ChangeLog | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) Index: metalic/ChangeLog --- metalic/ChangeLog (revision 0) +++ metalic/ChangeLog (revision 0) @@ -0,0 +1,42 @@ +2006-01-25 Thierry Geraud <theo(a)lrde.epita.fr> + + Clean up of core mlc classes and add some documentation. + + A lot of cleanups. Client concrete classes in mlc are now all + postfixed by '_'. For instance, we have and_, int_, and so on. + + * .: New. + * mlc: New. + * mlc/type.hh: New. + * mlc/bool.hh: New. + (abstract::boolean): New class. + (bool_): New class. + (value, true_type, false_type): Rename as... + (value_, true_, false_): ...these. + (ors, ands): Rename as... + (ors_, ands_): ...these. + (internal): Cosmetic change. + (is_true, is_false): Remove. + (true_, false_): New typedef ensure_t. + * mlc/is_a.hh: New. + (form): Move in the internal namespace cause names are too long + for a decent client use. + * mlc/value.hh: New. + (value): Rename as... + (value_): ...this. + (mlc_internal_decl_unsigned_): New macro. + (mlc_internal_decl_signed_): New macro. + (uchar_, ushort_, uint_, ulong_): New classes. + (schar_, short_, int_, long_): New classes. + (is_value, is_not_value): New meta-functions. + * mlc/flags.hh: New. + (flag): New abstract class. + (undefined_type, unknown_type, no_type): Rename as... + (undefined, unknown, none): ...these. + (not_ok): Remove cause useless. + * mlc/cmp.hh: New. + (eq, neq): Rename as... + (eq_, neq_): ...these. + (is_found, is_not_found, is_ok): Remove cause irrelevant here. + (mlc_is_found, mlc_is_not_found): Likewise. + * mlc/typedef.hh: New.

1 0

384: Clean up of core mlc classes and add some documentation.
by Thierry Geraud 25 Jan '06

25 Jan '06

https://svn.lrde.epita.fr/svn/oln/trunk Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Clean up of core mlc classes and add some documentation. A lot of cleanups. Client concrete classes in mlc are now all postfixed by '_'. For instance, we have and_, int_, and so on. * metalic: New. * metalic/mlc: New. * metalic/mlc/type.hh: New. * metalic/mlc/bool.hh: New. (abstract::boolean): New class. (bool_): New class. (value, true_type, false_type): Rename as... (value_, true_, false_): ...these. (ors, ands): Rename as... (ors_, ands_): ...these. (internal): Cosmetic change. (is_true, is_false): Remove. (true_, false_): New typedef ensure_t. * metalic/mlc/is_a.hh: New. (form): Move in the internal namespace cause names are too long for a decent client use. * metalic/mlc/value.hh: New. (value): Rename as... (value_): ...this. (mlc_internal_decl_unsigned_): New macro. (mlc_internal_decl_signed_): New macro. (uchar_, ushort_, uint_, ulong_): New classes. (schar_, short_, int_, long_): New classes. (is_value, is_not_value): New meta-functions. * metalic/mlc/flags.hh: New. (flag): New abstract class. (undefined_type, unknown_type, no_type): Rename as... (undefined, unknown, none): ...these. (not_ok): Remove cause useless. * metalic/mlc/cmp.hh: New. (eq, neq): Rename as... (eq_, neq_): ...these. (is_found, is_not_found, is_ok): Remove cause irrelevant here. (mlc_is_found, mlc_is_not_found): Likewise. * metalic/mlc/typedef.hh: New. bool.hh | 417 ++++++++++++++++++++++++++++++++++++++++++++++++--------------- cmp.hh | 46 ++---- flags.hh | 83 +++++++++--- is_a.hh | 67 ++++------ type.hh | 61 +++++++++ value.hh | 154 +++++++++++++++++++++-- 6 files changed, 624 insertions(+), 204 deletions(-) Index: metalic/mlc/type.hh --- metalic/mlc/type.hh (revision 0) +++ metalic/mlc/type.hh (revision 0) @@ -0,0 +1,61 @@ +// Copyright (C) 2006 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef METALIC_TYPE_HH +# define METALIC_TYPE_HH + + +namespace mlc { + + namespace abstract { + + /*! \class mlc::abstract::type + ** + ** Abstract base class for about all the types defined in the mlc + ** library. Types deriving from this class are intended to be + ** used only as types, not as objects; so they cannot be + ** instantiated. + ** + ** This class is useful to check at compile-time that a parameter + ** P is an mlc type (with the "mlc_is_a" facility). + ** + ** Example: mlc::true_ is a mlc::abstract::type. + */ + + struct type + { + private: + /// Ctor is private to prevent instantiations. + type() {} + }; + + } // end of namespace mlc::abstract + +} // end of namespace mlc + + +#endif // ! METALIC_TYPE_HH Index: metalic/mlc/bool.hh --- metalic/mlc/bool.hh (revision 0) +++ metalic/mlc/bool.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -29,166 +29,385 @@ # define METALIC_BOOL_HH # include <mlc/value.hh> -# include <mlc/types.hh> -/// Macro that retrieves a Boolean value from a static type representing a Boolean. -# define mlc_bool(Type) mlc::internal::helper_get_bool< Type >::ret +/*! \macro mlc_bool(T) +** +** Macro that retrieves a Boolean value from a Boolean expression type +** T. Its result is either true or false. +*/ +# define mlc_bool(Type) mlc::internal::get_bool<Type>::value namespace mlc { - /// Specializations of mlc::value for T = bool; when v = true, ensure() is provided. + namespace abstract { - template <> - struct value <bool, true> - { - static const bool Boolean_value = true; - static const bool val = true; - static void ensure() {} - protected: - value() {} - }; + /*! \class mlc::abstract::boolean + ** + ** Abstract base class for Booleans represented as types. This + ** class has two important sub-classes: mlc::true_ and + ** mlc::false_. + ** + ** Any mlc Boolean expression type derives from either mlc::true_ + ** or mlc::false_ so derives from mlc::abstract::boolean. + */ - template <> - struct value <bool, false> - { - static const bool Boolean_value = false; - static const bool val = false; - protected: - value() {} - }; + struct boolean : public value {}; + + } // end of mlc::abstract - /// Typedefs of true_type and false_type. - typedef value<bool, true> true_type; - typedef value<bool, false> false_type; + // fwd decl + template <bool> struct bool_; namespace internal { + /*! \class mlc::get_bool<T> + ** + ** Internal class so do not use it. This class gives access to a + ** Boolean value from a Boolean expression type; it is used in the + ** mlc_bool(T) macro. + ** + ** \see mlc_bool(T) + */ template <typename T> - struct helper_get_bool + struct get_bool { - // FIXME: static check that T dderives from either true_type or false_type... - static const bool ret = T::Boolean_value; + static const bool value = T::bool_value_; }; - } // end of namespace mlc::internal - - - /// Classes is_true and is_false (only provided for bkd compability). + /*! \class mlc::value_<bool, b> + ** + ** Specialization of value_<T, val> for the Boolean case. + ** + ** Design notes: 1) This specialization is defined so that mlc + ** Booleans derive from mlc::abstract::boolean. 2) This + ** specialization conforms to the interface of the generic version + ** of mlc::internal::value_. + */ - template <bool b> struct is_true {}; - template <> struct is_true <true> { static void ensure() {} }; + template <bool b> + struct value_ <bool, b> : public abstract::boolean + { + /*! \typedef type + ** + ** Gives the regular type, that is bool, corresponding to this + ** class. + */ + typedef bool type; + + /*! \member value + ** + ** Gives the regular value of the Boolean represented by this + ** class. The result is either true or false. + ** + ** This member is provided for any mlc value class such as + ** mlc::int_<51> and mlc::char_<'c'>. However, to access the + ** regular value of a type T that you know to be a mlc Boolean + ** expression, you should prefer to use the macro mlc_bool(T). + ** This macro also ensures that T really is an expression. + ** + */ + static const bool value = b; + + /*! \typedef ret + ** + ** Returns mlc::true_ or mlc::false_. + ** + ** Since Boolean expression types derive from either mlc::true_ + ** or mlc::false_, these expression types are never exactly + ** mlc::true_ nor mlc::false_. This typedef thus allows for the + ** expression evaluation. + ** + ** Please note that, however, we usually do not need expression + ** evaluation. The most common use of a Boolean expression is + ** to check that it is verified (true) and, for that, we provide + ** ::ensure() and ::ensure_t. + ** + ** \see mlc::true_ and mlc::false_ + */ + typedef bool_ ret; + + private: + + /*! \member bool_value_ + ** + ** This member is redundant with the member 'value'. It is used + ** by the mlc_bool(T) macro to ensure that T actually derives + ** from mlc::true_ or mlc::false_. + */ + static const bool bool_value_ = b; - template <bool b> struct is_false {}; - template <> struct is_false <false> { static void ensure() {} }; + template <typename T> friend class get_bool; + }; + } // end of namespace mlc::internal - /// Logical unary not of a Boolean type + /*! \class mlc::bool_<true> + ** + ** Specialization of mlc::bool_ for b set to true. This type + ** is also known as mlc::true_. Every Boolean expression types + ** derive either from this type or from mlc::false_. + ** + ** Design notes: 1) This specialization is defined so that mlc + ** Booleans derive from mlc::abstract::boolean. 2) This + ** specialization conforms to the interface of the generic version + ** of mlc::internal::value_. + ** + ** \see mlc::bool_<false> + */ - template <typename T> - struct not_ : public value<bool, !mlc_bool(T)> + template <> + struct bool_<true> : public internal::value_<bool, true> { - // FIXME: static assert here and below s.a. ~not_() { mlc_is_a(not_<T>, Boolean_value); } - }; + /*! \member ensure() + ** + ** This member is inherited in every Boolean expression types that + ** derive from mlc::true_. This member is not provided in + ** mlc::false_. + ** + ** A static check to ensure that a Boolean expression type, say + ** Expr, is verified can thus be written as an instruction: + ** "Expr::ensure();" + ** + ** When there is no room in code for an instruction, use + ** ensure_t instead. + ** + ** Design note: This member is a no-op (it has no cost at + ** run-time). + */ + static void ensure() {} - /// Logical binary operators between a couple of Boolean types + /*! \typedef ensure_t + ** + ** This typedef is inherited in every Boolean expression types that + ** derive from mlc::true_. This typedef is not provided in + ** mlc::false_. The type returned by this typedef has no meaning + ** (and thus no significant value). + ** + ** A static check to ensure that a Boolean expression type, say + ** Expr, is verified can thus be written through the typedef + ** access: "Expr::ensure_t". This is a replacement for the + ** instruction "Expr::ensure();" when there is no room in code for + ** an instruction. + ** + ** Sample use: + ** template <class T> + ** struct foo + ** : private mlc_is_a(T, base)::ensure_t + ** { + ** //... + ** }; + ** meaning that foo's parameter is constrainted to be a sub-class + ** of base. + ** + ** Limitation: when using ensure_t to express several + ** constraints through private inheritance, such as in the sample + ** use above, one should express the set of constraints by a + ** single expression. The following code is not ok: + ** template <class T1, class T2> + ** struct foo + ** : private mlc_is_a(T1, base)::ensure_t, + ** private mlc_is_a(T2, base)::ensure_t + ** { ... }; + ** the problem being that we mulitply inherit from the same + ** class. The correct code should be written with a single + ** Boolean; practically the following code is ok: + ** template <class T1, class T2> + ** struct foo + ** : private mlc::and_<mlc_is_a(T1, base), + ** mlc_is_a(T2, base)>::ensure_t + ** { ... }; + */ + typedef struct{} ensure_t; + }; - template <typename L, typename R> struct and_ : public value <bool, (mlc_bool(L) && mlc_bool(R)) > {}; - template <typename L, typename R> struct nand_ : public value <bool, (!(mlc_bool(L) && mlc_bool(R)))> {}; - template <typename L, typename R> struct or_ : public value <bool, (mlc_bool(L) || mlc_bool(R)) > {}; - template <typename L, typename R> struct nor_ : public value <bool, (!(mlc_bool(L) || mlc_bool(R)))> {}; - template <typename L, typename R> struct xor_ : public value <bool, (mlc_bool(L) != mlc_bool(R)) > {}; - template <typename L, typename R> struct xnor_ : public value <bool, (!(mlc_bool(L) != mlc_bool(R)))> {}; + typedef bool_<true> true_; + /*! \class mlc::bool_<false> + ** + ** Specialization of mlc::bool_ for b set to false. This type + ** is also known as mlc::false_. Every Boolean expression types + ** derive either from this type or from mlc::true_. + ** + ** Conversely to mlc::true_, this class does not feature ensure() + ** nor ensure_t. So, when a Boolean expression type, say Expr, + ** is evaluated to false, the static checks "Expr::ensure();" and + ** "Expr::ensure_t" do not compile. + ** + ** Design notes: 1) This specialization is defined so that mlc + ** Booleans derive from mlc::abstract::boolean. 2) This + ** specialization conforms to the interface of the generic version + ** of mlc::internal::value_. + ** + ** \see mlc::bool_<true> + */ - namespace internal + template <> + struct bool_<false> : public internal::value_<bool, false> { - // helpers for mlc::ors + }; - template <typename A1, typename A2> - struct ors2 : public or_<A1, A2> {}; + typedef bool_<false> false_; + + + /*! \class mlc::not_<T> + ** + ** Logical unary 'not' operator on a Boolean expression type. This + ** class is also a Boolean expression type. + */ + template <typename T> struct not_ : public bool_<(!mlc_bool(T))> {}; + + + /*! \class mlc::and_<L,R> + ** + ** Logical binary 'and' operator on a couple of Boolean expression + ** types. This class is also a Boolean expression type. + ** + ** \see mlc::ands_<..> + */ + template <typename L, typename R> struct and_ : public bool_< (mlc_bool(L) && mlc_bool(R)) > {}; + + /*! \class mlc::nand_<L,R> + ** + ** Logical binary 'not and' operator on a couple of Boolean + ** expression types. This class is also a Boolean expression type. + ** + ** Design note: an equivalent is mlc::not_< mlc::and_<L,R> >. + */ + template <typename L, typename R> struct nand_ : public bool_<(!(mlc_bool(L) && mlc_bool(R)))> {}; + + /*! \class mlc::or_<L,R> + ** + ** Logical binary 'or' operator on a couple of Boolean expression + ** types. This class is also a Boolean expression type. + ** + ** \see mlc::ors_<..> + */ + template <typename L, typename R> struct or_ : public bool_< (mlc_bool(L) || mlc_bool(R)) > {}; + + /*! \class mlc::nor_<L,R> + ** + ** Logical binary 'not or' operator on a couple of Boolean + ** expression types. This class is also a Boolean expression type. + ** + ** Design note: an equivalent is mlc::not_< mlc::or_<L,R> >. + */ + template <typename L, typename R> struct nor_ : public bool_<(!(mlc_bool(L) || mlc_bool(R)))> {}; + + /*! \class mlc::xor_<L,R> + ** + ** Logical binary 'exclusive or' operator on a couple of Boolean + ** expression types. This class is also a Boolean expression type. + */ + template <typename L, typename R> struct xor_ : public bool_< (mlc_bool(L) != mlc_bool(R)) > {}; + + /*! \class mlc::xnor_<L,R> + ** + ** Logical binary 'exclusive not or' operator on a couple of Boolean + ** expression types. This class is also a Boolean expression type. + */ + template <typename L, typename R> struct xnor_ : public bool_<(!(mlc_bool(L) != mlc_bool(R)))> {}; - template <> - struct ors2 <no_type, no_type> : public true_type {}; - template <typename A1> - struct ors2 <A1, no_type> : public A1 {}; + /// Internal helpers for logical operators between several Boolean types - template <typename A2> - struct ors2 <no_type, A2>; + namespace internal + { + struct none_; + // ors_2_ + template <typename A1, typename A2> struct ors_2_ : public or_<A1, A2> {}; + template <> struct ors_2_ <none_, none_> : public true_ {}; + template <typename A1> struct ors_2_ <A1, none_> : public A1 {}; + template <typename A2> struct ors_2_ <none_, A2>; + // ors_4_ template <typename A1, typename A2, typename A3, typename A4> - struct ors4 : public ors2< ors2<A1, A2>, ors2<A3, A4> > {}; - + struct ors_4_ : public ors_2_< ors_2_<A1, A2>, + ors_2_<A3, A4> > {}; template <> - struct ors4 <no_type, no_type, no_type, no_type> : public true_type {}; - + struct ors_4_ <none_, none_, none_, none_> : public true_ {}; + // ors_8_ template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> - struct ors8 : public ors2< ors4<A1, A2, A3, A4>, ors4<A5, A6, A7, A8> > {}; - - // helpers for mlc::ands - - template <typename A1, typename A2> - struct ands2 : public and_<A1, A2> {}; - - template <> - struct ands2 <no_type, no_type> : public true_type {}; - - template <typename A1> - struct ands2 <A1, no_type> : public A1 {}; - - template <typename A2> - struct ands2 <no_type, A2>; - + struct ors_8_ : public ors_2_< ors_4_<A1, A2, A3, A4>, + ors_4_<A5, A6, A7, A8> > {}; + // ands_2_ + template <typename A1, typename A2> struct ands_2_ : public and_<A1, A2> {}; + template <> struct ands_2_ <none_, none_> : public true_ {}; + template <typename A1> struct ands_2_ <A1, none_> : public A1 {}; + template <typename A2> struct ands_2_ <none_, A2>; + // ands_4_ template <typename A1, typename A2, typename A3, typename A4> - struct ands4 : public ands2< ands2<A1, A2>, ands2<A3, A4> > {}; - + struct ands_4_ : public ands_2_< ands_2_<A1, A2>, + ands_2_<A3, A4> > {}; template <> - struct ands4 <no_type, no_type, no_type, no_type> : public true_type {}; - + struct ands_4_ <none_, none_, none_, none_> : public true_ {}; + // ands_8_ template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> - struct ands8 : public ands2< ands4<A1, A2, A3, A4>, ands4<A5, A6, A7, A8> > {}; + struct ands_8_ : public ands_2_< ands_4_<A1, A2, A3, A4>, + ands_4_<A5, A6, A7, A8> > {}; } // end of mlc::internal - // 'ors' is a list of 'or_'. + /*! \class mlc::ors_<..> + ** + ** Logical n-ary 'or' operator on a set of Boolean expression types. + ** The number of arguments (parameters) should be at least 3 and at + ** most 8. This class is also a Boolean expression type. + ** + ** Sample use: + ** mlc::ors_< mlc::eq_<T, int>, + ** mlc_is_a(T, mlc::int_), + ** mlc_is_a(T, my::integer) > + ** + ** \see mlc::or_<L,R> mlc::ands_<..> + */ template <typename A1, typename A2, typename A3, - typename A4 = no_type, - typename A5 = no_type, - typename A6 = no_type, - typename A7 = no_type, - typename A8 = no_type> - struct ors : public internal::ors8< A1, A2, A3, A4, A5, A6, A7, A8 > - {}; + typename A4 = internal::none_, + typename A5 = internal::none_, + typename A6 = internal::none_, + typename A7 = internal::none_, + typename A8 = internal::none_> + struct ors_ : public internal::ors_8_< A1, A2, A3, A4, A5, A6, A7, A8 > + { + }; + - // 'ands' is a list of 'and_'. + /*! \class mlc::ands_<..> + ** + ** Logical n-ary 'and' operator on a set of Boolean expression types. + ** The number of arguments (parameters) should be at least 3 and at + ** most 8. This class is also a Boolean expression type. + ** + ** \see mlc::and_<L,R> mlc::ors_<..> + */ template <typename A1, typename A2, typename A3, - typename A4 = no_type, - typename A5 = no_type, - typename A6 = no_type, - typename A7 = no_type, - typename A8 = no_type> - struct ands : public internal::ands8< A1, A2, A3, A4, A5, A6, A7, A8 > - {}; + typename A4 = internal::none_, + typename A5 = internal::none_, + typename A6 = internal::none_, + typename A7 = internal::none_, + typename A8 = internal::none_> + struct ands_ : public internal::ands_8_< A1, A2, A3, A4, A5, A6, A7, A8 > + { + }; } // end of namespace mlc Index: metalic/mlc/is_a.hh --- metalic/mlc/is_a.hh (revision 0) +++ metalic/mlc/is_a.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -28,13 +28,13 @@ #ifndef METALIC_IS_A_HH # define METALIC_IS_A_HH -# include <mlc/any.hh> # include <mlc/bool.hh> -// private macro so do _not_ use it -# define is_a__check_result_ \ -sizeof(helper<T ,U >::check( (T *) helper<T,U >::makeT() )) \ -== sizeof(mlc::internal::yes_) + + +// internal macro so do not use it +# define mlc_internal_is_a__check_result_ \ +sizeof(helper<T ,U >::check( (T *) helper<T,U >::makeT() )) == sizeof(mlc::internal::yes_) namespace mlc @@ -44,23 +44,13 @@ { // - // wrap - // - // FIXME: This type is a workaround for g++-2.95 problem with implicit - // typename in <foo<T>::ret::dim>, - // write <wrap<typename foo<T>::ret>::dim instead. - // - + // wrap is a workaround to fix g++-2.95 problem with implicit: + // instead of typename in <foo<T>::ret::dim> + // write <wrap<typename foo<T>::ret>::dim template <class T> struct wrap : public T {}; - } // internal - - /*-----. - | is_a | - `-----*/ - // FIXME: form is a namespace to avoid g++-3.2 bug with template function - // overloading in class. + /// form namespace form { @@ -93,10 +83,9 @@ static desc< template_l_template_l_class_class_g_class_g_class_ > get(); // ... - } - namespace internal - { + } // end of namespace mlc::internal::form + typedef char yes_; struct no_ { char dummy[2]; }; @@ -125,7 +114,7 @@ template<class T, class U> struct check - : public value<bool,( is_a__check_result_ )> + : public bool_<( mlc_internal_is_a__check_result_ )> { }; }; @@ -148,7 +137,7 @@ template<class T, template < class > class U> struct check - : public value<bool,( is_a__check_result_ )> + : public bool_<( mlc_internal_is_a__check_result_ )> { }; }; @@ -171,7 +160,7 @@ template<class T, template < class,class > class U> struct check - : public value<bool,( is_a__check_result_ )> + : public bool_<( mlc_internal_is_a__check_result_ )> {}; }; @@ -193,7 +182,7 @@ template<class T, template < template < class > class > class U> struct check - : public value<bool,( is_a__check_result_ )> + : public bool_<( mlc_internal_is_a__check_result_ )> {}; }; @@ -215,26 +204,24 @@ template<class T, template < template < class,class > class > class U> struct check - : public value<bool,( is_a__check_result_ )> + : public bool_<( mlc_internal_is_a__check_result_ )> {}; }; - } // end of internal -} // end of mlc + } // end of namespace mlc::internal -// private macros: do _not_ use them -# define is_a__2nd_is_meta(T,U) mlc::internal::is_a_< id_of_typeform(U) >::check<T, U > +} // end of namespace mlc -// client macros -# define id_of_typeform(T) sizeof(mlc::form::get<T >()) -template <class T> -struct id_ { typedef T ret; }; +/// Client macro mlc_is_a(T, U) + +# define mlc_is_a(T, U) \ +mlc::internal::wrap<typename mlc::internal::is_a_< sizeof(mlc::internal::form::get()) >::check<T, U > > + +# define mlc_is_a_(T, U) \ +mlc::internal::wrap< mlc::internal::is_a_< sizeof(mlc::internal::form::get()) >::check<T, U > > -// FIXME: can we get rid of mlc::wrap ? -# define mlc_is_a(T, U) mlc::internal::wrap<typename mlc::internal::is_a_< id_of_typeform(U) >::check<T, U > > -# define mlc_is_a_(T, U) mlc::internal::wrap<mlc::internal::is_a_< id_of_typeform(U) >::check<T, U > > -#endif // ndef METALIC_IS_A_HH +#endif // ! METALIC_IS_A_HH Index: metalic/mlc/value.hh --- metalic/mlc/value.hh (revision 0) +++ metalic/mlc/value.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2005 EPITA Research and Development Laboratory +// Copyright (C) 2005, 2006 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -28,23 +28,155 @@ #ifndef METALIC_VALUE_HH # define METALIC_VALUE_HH +# include <mlc/type.hh> + + + +/// Internal macros. + + +# define mlc_internal_decl_unsigned_(Type, TypeName) \ +namespace internal \ +{ \ + template <Type val> \ + struct value_ <Type, val> : public abstract::unsigned_integer \ + { \ + typedef Type type; \ + static const Type value = val; \ + }; \ +} \ +template <Type val> \ +struct TypeName : public internal::value_<Type, val> {} + + +# define mlc_internal_decl_signed_(Type, TypeName) \ +namespace internal \ +{ \ + template <Type val> \ + struct value_ <Type, val> : public abstract::signed_integer \ + { \ + typedef Type type; \ + static const Type value = val; \ + }; \ +} \ +template <Type val> \ +struct TypeName : public internal::value_<Type, val> {} + + + -/*! \namespace mlc -** \brief mlc namespace. -*/ namespace mlc { - /// Class that defines a mlc value as a type (for instance mlc::value<int,3>). - template <typename T, T v> - struct value - { - static const T val = v; - value() {} - operator T() const { return v; } + namespace abstract { + + /*! \class mlc::abstract::value + ** + ** Abstract base class for mlc types that represent values. + ** + ** For instance, the types mlc::true_ and mlc::int_<51> derive + ** from this abstraction. + */ + + struct value : public type + { + }; + + /// Abstractions for integer values as types. + + struct integer : public value {}; + struct unsigned_integer : public integer {}; + struct signed_integer : public integer {}; + + } // end of namespace mlc::abstract + + + namespace internal + { + + /*! \class mlc::internal::value_<T, val> + ** + ** Base class for values to be represented by types. This class + ** is in the internal namespace so you should not use it. Its + ** purpose is only to factor code for derived classes that are not + ** internal (for instance, mlc::true_ or mlc::int_<51>). + ** + ** Design note: this class can only be used for values that can be + ** a parameter (mlc::internal::value_<float, 3.14f> is incorrect). + ** + ** Parameter T is the type of the value. Parameter val is the + ** value itself. + ** + ** \see mlc/bool.hh + */ + + template <typename T, T val> + struct value_ : public abstract::value + { + /*! \typedef type + ** + ** Gives the regular type of the value. For instance, + ** mlc::true_::type is bool and mlc::int_<51>::type is int. + */ + typedef T type; + + /*! \member value + ** + ** Gives the regular value. For instance, + ** mlc::true_::value is true and mlc::int_<51>::value is 51. + */ + static const T value = val; + }; + + } // end of namespace mlc::internal + + + + + // Dedicated sub-classes for builtin types. + + mlc_internal_decl_unsigned_( unsigned char, uchar_ ); + mlc_internal_decl_unsigned_( unsigned short, ushort_ ); + mlc_internal_decl_unsigned_( unsigned int, uint_ ); + mlc_internal_decl_unsigned_( unsigned long, ulong_ ); + + mlc_internal_decl_signed_( signed char, schar_ ); + mlc_internal_decl_signed_( signed short, short_ ); + mlc_internal_decl_signed_( signed int, int_ ); + mlc_internal_decl_signed_( signed long, long_ ); + + + // char + + template <char c> + struct char_ : public internal::value_<char, c> + { }; + // Boolean values as types are defined elsewhere + // see: mlc/bool.hh + + +} // end of namespace mlc + + +# include <mlc/bool.hh> +# include <mlc/is_a.hh> + + +namespace mlc { + + template <typename T> + struct is_value : public mlc_is_a(T, mlc::abstract::value) + { + }; + + template <typename T> + struct is_not_value : public not_<mlc_is_a(T, mlc::abstract::value)> + { + }; + } // end of namespace mlc Index: metalic/mlc/flags.hh --- metalic/mlc/flags.hh (revision 0) +++ metalic/mlc/flags.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2005 EPITA Research and Development Laboratory +// Copyright (C) 2005, 2006 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -25,39 +25,78 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef METALIC_TYPES_HH -# define METALIC_TYPES_HH +#ifndef METALIC_FLAGS_HH +# define METALIC_FLAGS_HH +# include <mlc/type.hh> -/*! \namespace mlc -** \brief mlc namespace. -*/ namespace mlc { - /*! \class undefined_type + namespace abstract { + + /*! \class mlc::abstract::flag + ** + ** Abstract base class for types that are only flags. + ** + ** Example: mlc::undefined is a mlc::abstract::flag. + */ + + struct flag : public type {}; + + } // end of namespace mlc::abstract + + + /*! \class mlc::undefined + ** + ** Flag class to state that a type is undefined, that is, declared + ** but not defined. + ** + ** Sample use: you want to define a trait to get the signed version + ** of a type T. For that, you write: + ** + ** template <typename T> + ** struct signed_type_of + ** { + ** typedef mlc::undefined ret; + ** }; + ** + ** which means that the return type (ret) is not defined by default. + ** Put differently, this trait is just declared. So far, the + ** type "signed_type_of<unsigned short>::ret" is "mlc::undefined". + ** + ** Other flags are mlc::unknown, mlc::none, and mlc::not_found. + */ + struct undefined : public abstract::flag {}; + + struct unknown : public abstract::flag {}; + + struct none : public abstract::flag {}; + + + /*! \class mlc::not_found + ** + ** Flag class to state that a type is not found (for use in the + ** context of trying to retrieve a type). + ** + ** Design issue: this flag is used in some meta-code to handle the + ** case of an "absent" typedef. For instance it is used in the + ** meta-code behind mlc_typedef: + ** mlc_typedef(std::vector<int>, value_type) is int, whereas + ** mlc_typedef(std::vector<int>, walue_type) is mlc::not_found. + ** + ** Other flags are mlc::undefined, mlc::unknown, and mlc::none. ** - ** Type by default. If the programmer forgets to define a type, - ** actually this type should however exists and should be set to - ** undefined_type. + ** \see mlc_typedef */ - class undefined_type { private: undefined_type(); }; + struct not_found : public abstract::flag {}; - // FIXME: document. - class unknown_type { private: unknown_type(); }; - class no_type { private: no_type(); }; - class default_type { private: default_type(); }; - - namespace internal - { - class not_found { private: not_found(); }; - class not_ok { private: not_ok(); }; - } // end of namespace mlc::internal + // FIXME: add corresponding is_* types } // end of namespace mlc -#endif // ! METALIC_TYPES_HH +#endif // ! METALIC_FLAGS_HH Index: metalic/mlc/cmp.hh --- metalic/mlc/cmp.hh (revision 0) +++ metalic/mlc/cmp.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -29,62 +29,44 @@ # define METALIC_CMP_HH # include <mlc/bool.hh> -# include <mlc/types.hh> +# include <mlc/is_a.hh> /// Macros mlc_eq and mlc_neq. -# define mlc_eq(T1, T2) mlc::eq<T1, T2> -# define mlc_neq(T1, T2) mlc::neq<T1, T2> - -# define mlc_is_found(T) mlc::is_found<(T)> -# define mlc_is_not_found(T) mlc::is_not_found<(T)> +# define mlc_eq( T1, T2) mlc::eq_ <T1, T2> +# define mlc_neq(T1, T2) mlc::neq_<T1, T2> namespace mlc { + /// Equality test between a couple of types. template <typename T1, typename T2> - struct eq : public value<bool, false> + struct eq_ : private and_< is_not_value<T1>, is_not_value<T2> >::ensure_type, + public false_ { }; template <typename T> - struct eq <T, T> : public value<bool, true> + struct eq_ <T, T> : private is_not_value<T>::ensure_type, + public true_ { }; + /// Inequality test between a couple of types. template <typename T1, typename T2> - struct neq : public value<bool, true> - { - }; - - template <typename T> - struct neq <T, T> : public value<bool, false> - { - }; - - /// Tests is_found and is_not_found (sugar) upon a type. - - template <typename T> - struct is_found : public neq <T, internal::not_found> + struct neq_ : private and_< is_not_value<T1>, is_not_value<T2> >::ensure_type, + public true_ { }; template <typename T> - struct is_not_found : public eq <T, internal::not_found> - { - }; - - - - template <typename T> - struct is_ok : public and_< and_< neq<T, internal::not_found>, - neq<T, internal::not_ok> >, - neq<T, undefined_type> > + struct neq_ <T, T> : private is_not_value<T>::ensure_type, + public false_ { };

1 0

382: Add Vcs helper
by Roland Levillain 24 Jan '06

24 Jan '06

Hop, le premier commit de Olena 1.0. :) (Désolé pour le mail en retard, je me suis raté avec Vcs.) https://svn.lrde.epita.fr/svn/oln/trunk ChangeLog | 6 ++++++ vcs/oln.rb | 16 ++++++++++++++++ 2 files changed, 22 insertions(+) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add Vcs helper. * vcs/oln.rb: New. ++ vcs/oln.rb (révision 382) class Vcs # See http://rubyforge.org/projects/vcs # and http://vcs.rubyforge.org protocol_version '0.1' def olena_commit! ( *args ) common_commit!("<%= rev %>: <%= title %>", *args) do |subject| mail!(:to => %w['olena-patches(a)lrde.epita.fr'], :subject => subject) end end alias_command :olnci, :olena_commit default_commit :olena_commit end # class Vcs

2 3

383: Fix e-mail address in vcs/oln.rb.
by Roland Levillain 24 Jan '06

24 Jan '06

https://svn.lrde.epita.fr/svn/oln/trunk Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> * vcs/oln.rb: Fix e-mail address. oln.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) Index: vcs/oln.rb --- vcs/oln.rb (revision 382) +++ vcs/oln.rb (working copy) @@ -7,7 +7,7 @@ def olena_commit! ( *args ) common_commit!("<%= rev %>: <%= title %>", *args) do |subject| - mail!(:to => %w['olena-patches(a)lrde.epita.fr'], :subject => subject) + mail!(:to => %w[olena-patches(a)lrde.epita.fr], :subject => subject) end end alias_command :olnci, :olena_commit

1 0

proto-1.0 380: Fix laplacian convolution.
by Nicolas Widynski 20 Jan '06

20 Jan '06

https://svn/svn/oln/prototypes/proto-1.0/olena Index: ChangeLog from Nicolas Widynski <widyns_n(a)lrde.epita.fr> Fix laplacian convolution. * oln/convolution/laplacian.hh: Fix laplacian convolution. laplacian.hh | 52 ++++------------------------------------------------ 1 file changed, 4 insertions(+), 48 deletions(-) Index: oln/convolution/laplacian.hh --- oln/convolution/laplacian.hh (revision 379) +++ oln/convolution/laplacian.hh (working copy) @@ -40,16 +40,7 @@ template <typename I> oln_type_of(I, concrete) - laplacian_first_derivative(const abstract::image& input); - - template <typename I> - oln_type_of(I, concrete) - laplacian_second_derivative_xy_yx(const abstract::image& input); - - template <typename I> - oln_type_of(I, concrete) - laplacian_second_derivative_xx_yy(const abstract::image& input); - + laplacian(const abstract::image& input); namespace impl { @@ -58,28 +49,7 @@ template <typename I> oln_type_of(I, concrete) - laplacian_first_derivative_(const abstract::image2d& input) - { - oln_type_of(I, concrete) lpl(input.size(), "laplacian first derivative"); - oln_type_of(I, fwd_piter) p(input.size()); - oln_type_of(I, point) pt; - oln_type_of(I, value) v; - - for_all_p(p) - { - pt = p; - lpl[p] = (input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value() + - input[oln_type_of(I, point)((coord_t)(pt.row()), pt.col())].value() + - input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value() + - input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col()))].value() - - 4 * input[p].value()) / 4; - } - return lpl; - } - - template <typename I> - oln_type_of(I, concrete) - laplacian_second_derivative_xx_yy_(const abstract::image2d& input) + laplacian_(const abstract::image2d& input) { oln_type_of(I, concrete) lpl(input.size(), "laplacian second derivative"); oln_type_of(I, fwd_piter) p(input.size()); @@ -103,23 +73,9 @@ template <typename I> oln_type_of(I, concrete) - laplacian_first_derivative(const abstract::image& input) - { - return impl::laplacian_first_derivative_(input.exact()); - } - - template <typename I> - oln_type_of(I, concrete) - laplacian_second_derivative_xy_yx(const abstract::image& input) - { - return impl::laplacian_first_derivative_(impl::laplacian_first_derivative_(input.exact())); - } - - template <typename I> - oln_type_of(I, concrete) - laplacian_second_derivative_xx_yy(const abstract::image& input) + laplacian_(const abstract::image& input) { - return impl::laplacian_second_derivative_xx_yy_(input.exact()); + return impl::laplacian_(input.exact()); }

1 0

Update laplacian convolution.
by Nicolas 20 Jan '06

20 Jan '06

Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Update laplacian convolution. * oln/convolution/laplacian.hh: Update laplacian convolution for first and second derivatives. laplacian.hh | 66 +++++++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 55 insertions(+), 11 deletions(-) Index: oln/convolution/laplacian.hh --- oln/convolution/laplacian.hh (revision 378) +++ oln/convolution/laplacian.hh (working copy) @@ -40,19 +40,48 @@ template <typename I> oln_type_of(I, concrete) - laplacian(const abstract::image& input); + laplacian_first_derivative(const abstract::image& input); + + template <typename I> + oln_type_of(I, concrete) + laplacian_second_derivative_xy_yx(const abstract::image& input); + + template <typename I> + oln_type_of(I, concrete) + laplacian_second_derivative_xx_yy(const abstract::image& input); namespace impl { - // FIXME : type I must be a ntg::int_u8 + // FIXME : type I must be a ntg::int_s8 u8... + + template <typename I> + oln_type_of(I, concrete) + laplacian_first_derivative_(const abstract::image2d& input) + { + oln_type_of(I, concrete) lpl(input.size(), "laplacian first derivative"); + oln_type_of(I, fwd_piter) p(input.size()); + oln_type_of(I, point) pt; + oln_type_of(I, value) v; + + for_all_p(p) + { + pt = p; + lpl[p] = (input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value() + + input[oln_type_of(I, point)((coord_t)(pt.row()), pt.col())].value() + + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value() + + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col()))].value() - + 4 * input[p].value()) / 4; + } + return lpl; + } template <typename I> oln_type_of(I, concrete) - laplacian_(const abstract::image2d& input) + laplacian_second_derivative_xx_yy_(const abstract::image2d& input) { - oln_type_of(I, concrete) lpl(input.size(), "laplacian"); + oln_type_of(I, concrete) lpl(input.size(), "laplacian second derivative"); oln_type_of(I, fwd_piter) p(input.size()); oln_type_of(I, point) pt; oln_type_of(I, value) v; @@ -60,25 +89,40 @@ for_all_p(p) { pt = p; - lpl[p] = (abs(input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value() + - input[oln_type_of(I, point)((coord_t)(pt.row() + 1), pt.col())].value() - - 2 * input[p].value()) + - abs(input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value() + + lpl[p] = (input[oln_type_of(I, point)((coord_t)(pt.row() - 1), pt.col())].value() + + input[oln_type_of(I, point)((coord_t)(pt.row() + 1), pt.col())].value() + + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() - 1))].value() + input[oln_type_of(I, point)(pt.row(), (coord_t)(pt.col() + 1))].value() - - 2 * input[p].value())) % 255; + 4 * input[p].value()) / 4; } return lpl; } + } // end of namespace oln::convolution::impl template <typename I> oln_type_of(I, concrete) - laplacian(const abstract::image& input) + laplacian_first_derivative(const abstract::image& input) + { + return impl::laplacian_first_derivative_(input.exact()); + } + + template <typename I> + oln_type_of(I, concrete) + laplacian_second_derivative_xy_yx(const abstract::image& input) + { + return impl::laplacian_first_derivative_(impl::laplacian_first_derivative_(input.exact())); + } + + template <typename I> + oln_type_of(I, concrete) + laplacian_second_derivative_xx_yy(const abstract::image& input) { - return impl::laplacian_(input.exact()); + return impl::laplacian_second_derivative_xx_yy_(input.exact()); } + } // end of namespace oln::convolution } // end of namespace oln

1 0