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_<b> ret;
+ typedef bool_<b> 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_<b> 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_
{
};
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<b> and is_false<b> (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_<b> 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_<b> 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_<b> 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<U >()) >::check<T, U > >
+
+# define mlc_is_a_(T, U) \
+mlc::internal::wrap< mlc::internal::is_a_< sizeof(mlc::internal::form::get<U >()) >::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_
{
};
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
