- Olena-patches

Re: [Olena-patches] proto-1.0 445: Add GPL to trunk.
by Micha 03 Apr '06

03 Apr '06

Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> writes: > https://svn/svn/oln/prototypes/proto-1.0 > > Index: ChangeLog > from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> > > Add GPL to trunk. > > * COPYING: Modify FDL to Gnu General Public License. > > COPYING | 721 +++++++++++++++++++++++++++++----------------------------------- > 1 file changed, 332 insertions(+), 389 deletions(-) > HUGE !... -- | Mieux vaut se taire Michaël 'Micha' Cadilhac | | Que de parler trop fort. cadilh_m - Epita 2007 - CSI | | -- As de trèfle JID: micha(a)amessage.be | `-- - - - - --'

6 7

447: Add protection mechanism to case definitions and update.
by Thierry Geraud 03 Apr '06

03 Apr '06

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Add protection mechanism to case definitions and update. * tests/switch.cc: Update. * tests/protected.cc: New file. * tests/Makefile.am (protected): New entry. * mlc/ret.hh (mlc_ret_, mlc_ret_found_in): New macros. (ret_found_in_): Update. * mlc/if.hh (FIXME): Remove. (if_): Change inheritance into composition. * mlc/typedef.hh: Cosmetics. * mlc/switch.hh (mlc_switch, mlc_switch_): New macros. * mlc/TODO: Update. * mlc/case.hh (mlc_case, mlc_case_): New macros. (ERROR): Update and augment. (WARNING): New. (mlc_case_equipment_for_namespace): Update to handle protected_. * mlc/cmp.hh (mlc_is_found, mlc_is_not_found): New macros. (mlc_is_undefined, mlc_is_defined): New macros. (mlc_is_ok, mlc_is_not_ok): New macros. (is_value, is_not_value): Update. (is_not_found_, is_found_): Update. (is_not_ok_, is_ok_): Update. mlc/TODO | 51 ++++++++++--- mlc/case.hh | 194 +++++++++++++++++++++++++++++++++++++++++++++-------- mlc/cmp.hh | 64 +++++++++++++++-- mlc/if.hh | 12 ++- mlc/ret.hh | 13 +++ mlc/switch.hh | 12 +++ mlc/typedef.hh | 4 - tests/Makefile.am | 2 tests/protected.cc | 149 ++++++++++++++++++++++++++++++++++++++++ tests/switch.cc | 54 ++++++++++++++ 10 files changed, 501 insertions(+), 54 deletions(-) Index: tests/switch.cc --- tests/switch.cc (revision 446) +++ tests/switch.cc (working copy) @@ -31,7 +31,7 @@ typedef int ret; }; -// // or: +// // ok // template <class T> // struct case_ <test, T, 3> : public mlc::where_< mlc_is_a(T, char) > @@ -39,6 +39,20 @@ // typedef mlc::not_found ret; // }; +// // ok + +// template <class T> +// struct case_ <test, T, 3> : public mlc::where_< mlc_is_a(T, char) > +// { +// struct protected_ { +// typedef mlc::not_found ret; +// }; +// }; + + + + + // // ko @@ -54,6 +68,21 @@ // }; // template <class T> +// struct case_ <test, T, 3> : public mlc::where_< mlc_is_a(T, char) > +// { +// struct protected_ { +// }; +// typedef int ret; +// }; + +// template <class T> +// struct case_ <test, T, 3> : public mlc::where_< mlc_is_a(T, char) > +// { +// struct protected_ { +// }; +// }; + +// template <class T> // struct case_ <test, T, 3> // { // typedef int ret; @@ -70,10 +99,33 @@ // { // }; +// template <class T> +// struct default_case_ <test, T> : public mlc::where_< mlc_is_a(T, char) > +// { +// typedef int ret; +// }; + +// template <class T> +// struct default_case_ <test, T> +// { +// struct protected_ { +// typedef int ret; +// } +// typedef int ret; +// }; + +// template <class T> +// struct default_case_ <test, T> +// { +// struct protected_ { +// } +// }; + } // end of namespace client + template <class T> void print() { Index: tests/Makefile.am --- tests/Makefile.am (revision 446) +++ tests/Makefile.am (working copy) @@ -12,6 +12,7 @@ if \ is_a \ or \ + protected \ ret \ switch \ typedef @@ -20,6 +21,7 @@ if_SOURCES = if.cc is_a_SOURCES = is_a.cc or_SOURCES = or.cc +protected_SOURCES = protected.cc ret_SOURCES = ret.cc switch_SOURCES = switch.cc typedef_SOURCES = typedef.cc Index: tests/protected.cc --- tests/protected.cc (revision 0) +++ tests/protected.cc (revision 0) @@ -0,0 +1,149 @@ +#include <mlc/switch.hh> +#include <mlc/cmp.hh> +#include <mlc/typedef.hh> +#include <mlc/assert.hh> +#include <mlc/implies.hh> + + +mlc_case_equipment_for_namespace(client); +mlc_decl_typedef(protected_); + +template <typename T> +void reveal() +{ + T tmp; +} + + + +namespace client +{ + + struct A + { + typedef bool typedef_in_A_only; + }; + + struct B + { + typedef char typedef_in_B_only; + }; + + + + // simple_test + + struct simple_test; + + template <class T> + struct case_ <simple_test, T, 1> : public mlc::where_< mlc_eq(T, A) > + { + typedef A ret; + }; + + template <class T> + struct case_ <simple_test, T, 2> : public mlc::where_< mlc_eq(T, B) > + { + typedef B ret; + }; + + + // test_ok + + struct test_ok; + + template <class T> + struct case_ <test_ok, T, 1> : public mlc::where_< mlc_eq(T, A) > + { + typedef typename A::typedef_in_A_only ret; + }; + + template <class T> + struct case_ <test_ok, T, 2> : public mlc::where_< mlc_eq(T, B) > + { + typedef typename B::typedef_in_B_only ret; + }; + + + + // test_KO + + struct test_KO; + + template <class T> + struct case_ <test_KO, T, 1> : public mlc::where_< mlc_eq(T, A) > + { + typedef typename T::typedef_in_A_only ret; + }; + + template <class T> + struct case_ <test_KO, T, 2> : public mlc::where_< mlc_eq(T, B) > + { + typedef typename T::typedef_in_B_only ret; + }; + + + // test_soluce + + struct test_soluce; + + template <class T> + struct case_ <test_soluce, T, 1> : public mlc::where_< mlc_eq(T, A) > + { + struct protected_ { + typedef typename T::typedef_in_A_only ret; + }; + }; + + template <class T> + struct case_ <test_soluce, T, 2> : public mlc::where_< mlc_eq(T, B) > + { + // typedef mlc::dummy ret; + struct protected_ { + typedef typename T::typedef_in_B_only ret; + }; + }; + + + +} // end of namespace client + + +struct ERROR_USE_EITHER_PROTECT_OR_RET_IN_A_CASE; + + + +int main() +{ + + using namespace client; + + typedef switch_<simple_test, B>::ret type; + reveal<type>(); + + + // typedef switch_<test, B> ::ret type; + // which is equiv to: + // typedef case_<test, B>::ret ::ret type; + +// typedef case_<test_soluce, B>::ret ::protect::ret type; + + + + +// typedef case_<test_soluce, B>::ret the_case; +// typedef mlc_typedef_(the_case, protected_) the_case_protected; +// typedef mlc_ret_(the_case) the_case_ret; + +// mlc::assert_< mlc::xor_< mlc_is_found(the_case_protected), +// mlc_is_found(the_case_ret) >, +// ERROR_USE_EITHER_PROTECT_OR_RET_IN_A_CASE +// >::check(); + +// typedef mlc::if_< mlc::eq_< the_case_protected, mlc::not_found >, +// the_case_ret, +// mlc_ret_(the_case_protected) >::ret result; + + +// reveal<result>(); +} Index: mlc/ret.hh --- mlc/ret.hh (revision 446) +++ mlc/ret.hh (working copy) @@ -48,7 +48,14 @@ +/// \{ +/// Macros mlc_ret and mlc_ret_. + # define mlc_ret(Type) typename mlc::typedef_::ret::from_<Type>::ret +# define mlc_ret_(Type) mlc::typedef_::ret::from_<Type>::ret + +/// \} + // test code @@ -62,10 +69,14 @@ template <typename T> struct ret_found_in_ : public mlc::eq_< typename mlc::typedef_::ret::from_<T>::ret2::first_elt, - mlc::found > + mlc::found >::bexpr {}; } // end of namespace mlc +# define mlc_ret_found_in(T) mlc::ret_found_in_<T> + + + #endif // ! METALIC_RET_HH Index: mlc/if.hh --- mlc/if.hh (revision 446) +++ mlc/if.hh (working copy) @@ -53,10 +53,11 @@ namespace ERROR { - struct FIXME; + struct THE_FIRST_PARAMETER_OF_AN_mlc_if_SHOULD_BE_AN_mlc_bexpr; } // end of mlc::ERROR + namespace internal { @@ -92,13 +93,16 @@ ** \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_ : - // FIXME: enable the static assertion below!!! + private assert_< mlc_is_a(cond_type, mlc::abstract::bexpr), - mlc::ERROR::FIXME >, - public internal::if_ < mlc_bool(cond_type), then_type, else_type > + mlc::ERROR::THE_FIRST_PARAMETER_OF_AN_mlc_if_SHOULD_BE_AN_mlc_bexpr > { + typedef typename internal::if_< mlc_bool(cond_type), + then_type, + else_type >::ret ret; }; } // end of namespace mlc Index: mlc/typedef.hh --- mlc/typedef.hh (revision 446) +++ mlc/typedef.hh (working copy) @@ -242,6 +242,9 @@ + + + /*! \macro mlc_typedef_in(Namespace, Type, TypedefName) ** ** FIXME: doc @@ -254,7 +257,6 @@ Namespace::typedef_::TypedefName::from_<Type>::ret - /*! \macro mlc_typedef_onlyif(Type, TypedefName, Bexpr) ** ** FIXME: doc Index: mlc/switch.hh --- mlc/switch.hh (revision 446) +++ mlc/switch.hh (working copy) @@ -32,4 +32,16 @@ # include <mlc/case.hh> +/// Macros mlc_switch and mlc_switch_. +/// \{ + +# define mlc_switch(Namespace, Context, Data) \ + typename Namespace::switch_<Context, Data>::ret + +# define mlc_switch_(Namespace, Context, Data) \ + Namespace::switch_<Context, Data>::ret + +/// \} + + #endif // ! METALIC_SWITCH_HH Index: mlc/TODO --- mlc/TODO (revision 446) +++ mlc/TODO (working copy) @@ -2,15 +2,6 @@ * files -** bool.hh - -create assert.hh from parts of bool.hh - -** boolean and bexpr - -there is a confusion between mlc::abstract::boolean and the notion of -bexpr (Boolean expression type)! - ** value.hh This file mixes bool_, int_, etc. so I should be split into several @@ -21,7 +12,22 @@ * addition -mlc_eval (such as mlc_bool and mlc_value) +** macros + +*** mlc_eval + +mlc_eval should exist (in a similar way to mlc_bool and mlc_value) + +*** mlc_value + +rec pb + +** cmp.hh + +clearly check that params are neither values not bexprs + +clearly state the difference (and use cases) between mlc_eq and mlc_is_a +then check that is_something facilities conform to the use case rules * renaming @@ -50,6 +56,29 @@ works well and we do not have to write mlc_is_a_ with the '_' at the end so that's better. yet is it a direct consequence of the wrapping? +** if_ + +then_type and else_type are not protected; find a solution + +** logic.hh + +add some tests to check that err msg are ok +(the pb is that they may propagate...) + + + + +* DONE! + +** bool.hh + +create assert.hh from parts of bool.hh + +** boolean and bexpr + +there is a confusion between mlc::abstract::boolean and the notion of +bexpr (Boolean expression type)! + ** boolean and bexpr the last part of the disambiguation between boolean and bexpr is to @@ -63,5 +92,3 @@ static checks should change *** remove eval in true_ and false_ - - Index: mlc/case.hh --- mlc/case.hh (revision 446) +++ mlc/case.hh (working copy) @@ -30,6 +30,7 @@ # include <mlc/bexpr.hh> # include <mlc/assert.hh> +# include <mlc/abort.hh> # include <mlc/ret.hh> # include <mlc/is_a.hh> # include <mlc/implies.hh> @@ -38,6 +39,19 @@ # include <mlc/if.hh> +/// Macros mlc_case and mlc_case_. +/// \{ + +# define mlc_case(Namespace, Context, Data) \ + typename Namespace::case_<Context, Data>::ret + +# define mlc_case_(Namespace, Context, Data) \ + Namespace::case_<Context, Data>::ret + +/// \} + + + // FIXME: doc this file! @@ -59,14 +73,52 @@ namespace ERROR { + struct PARAMETER_OF_mlc_where_SHOULD_BE_A_BEXPR; + struct A_case_STATEMENT_SHOULD_NOT_START_AT_INDEX_0_BUT_1; + struct A_case_STATEMENT_SHOULD_DERIVE_FROM_mlc_where_; struct A_default_case_STATEMENT_SHOULD_NOT_DERIVE_FROM_mlc_where_; + + struct A_default_case_STATEMENT_IN_A_switch_SHOULD_HAVE_EITHER_A_ret_OR_A_protected; + struct A_default_case_STATEMENT_IN_A_switch_SHOULD_NOT_HAVE_BOTH_A_ret_AND_A_protected; + struct THE_protected_PART_OF_A_default_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret; + + struct A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_EITHER_A_ret_OR_A_protected; + struct A_case_STATEMENT_IN_A_switch_SHOULD_NOT_HAVE_BOTH_A_ret_AND_A_protected; + struct THE_protected_PART_OF_A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret; + struct NO_case_STATEMENT_CAN_BE_SELECTED; - struct A_default_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret; - struct A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret; - struct PARAMETER_OF_mlc_where_SHOULD_BE_A_BEXPR; - } + + } // end of namespace mlc::ERROR + + + namespace WARNING + { + struct NO_default_case_STATEMENT_HAS_BEEN_DEFINED; + + } // end of namespace mlc::WARNING + + + + namespace internal + { + + template <typename T, typename T_is_bexpr> + struct where_; + + template <typename bexpr> + struct where_ < bexpr, mlc::true_ > + : public mlc_if_(bexpr, case_selected, case_not_selected) + { + }; + + template <typename T> + struct where_ < T, mlc::false_ > + { + }; + + } // end of namespace mlc::internal template <typename bexpr> @@ -75,11 +127,17 @@ private assert_< mlc_is_a(bexpr, mlc::abstract::bexpr), mlc::ERROR::PARAMETER_OF_mlc_where_SHOULD_BE_A_BEXPR >, - public mlc_if_( bexpr, case_selected, case_not_selected ) + // hack so that the error above cannot propagate to the mlc_if_ + public internal::where_< bexpr, + typename mlc_is_a(bexpr, mlc::abstract::bexpr)::eval > { }; + + mlc_decl_typedef(protected_); + + } // end of namespace mlc @@ -114,6 +172,17 @@ }; \ \ \ + template <typename a_case> \ + struct protected_in_ \ + { \ + typedef typename mlc::typedef_::protected_::from_<a_case>::ret the; \ + typedef typename mlc::is_found_<the>::bexpr is_found; \ + typedef typename mlc::ret_found_in_<the>::bexpr is_found_with_ret; \ + typedef mlc_ret(the) ret; \ + }; \ + \ + \ + \ namespace internal \ { \ \ @@ -129,20 +198,53 @@ struct handle_case_ <use, context, data, i, 1, 1>; \ \ \ - template <typename use, typename context, typename data> \ - struct handle_default_case_ \ + template <typename use, \ + typename context, typename data> \ + struct handle_default_case_; \ + \ \ - : private mlc::assert_< mlc::implies_< mlc_is_not_a(mlc_comma_1(NAMESPACE::default_case_<context, data>), \ - mlc::undefined), \ + \ + template <typename context, typename data> \ + struct handle_default_case_ < mlc::internal::a_simple_case, context, data > \ + \ + : private mlc::assert_< mlc::implies_< mlc::is_defined_< NAMESPACE::default_case_<context, data> >, \ mlc_is_not_a(mlc_comma_1(NAMESPACE::default_case_<context, data>), \ mlc::where_) >, \ - mlc::ERROR::A_default_case_STATEMENT_SHOULD_NOT_DERIVE_FROM_mlc_where_ >, \ + mlc::ERROR::A_default_case_STATEMENT_SHOULD_NOT_DERIVE_FROM_mlc_where_ > \ + { \ + typedef NAMESPACE::default_case_<context, data> case_t; \ + typedef typename protected_in_<case_t>::the protected_case_t; \ \ - private mlc::assert_< mlc::implies_< mlc::and_< mlc::eq_<use, mlc::internal::a_switch_case>, \ + typedef typename mlc::if_< mlc::is_found_<protected_case_t>, \ + protected_case_t, \ + case_t >::ret ret; \ + }; \ + \ + \ + template <typename context, typename data> \ + struct handle_default_case_ < mlc::internal::a_switch_case, context, data > \ + \ + : private mlc::assert_< mlc::implies_< mlc::is_defined_< NAMESPACE::default_case_<context, data> >, \ mlc_is_not_a(mlc_comma_1(NAMESPACE::default_case_<context, data>), \ - mlc::undefined) >, \ - mlc::ret_found_in_< NAMESPACE::default_case_<context, data> > >, \ - mlc::ERROR::A_default_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret > \ + mlc::where_) >, \ + mlc::ERROR::A_default_case_STATEMENT_SHOULD_NOT_DERIVE_FROM_mlc_where_ >, \ + \ + private mlc::assert_< mlc::implies_< mlc::is_defined_< NAMESPACE::default_case_<context, data> >, \ + mlc::or_< mlc::ret_found_in_< NAMESPACE::default_case_<context, data> >, \ + typename protected_in_< NAMESPACE::default_case_<context, data> >::is_found > >, \ + mlc::ERROR::A_default_case_STATEMENT_IN_A_switch_SHOULD_HAVE_EITHER_A_ret_OR_A_protected >, \ + \ + private mlc::assert_< mlc::implies_< mlc::and_< mlc::is_defined_< NAMESPACE::default_case_<context, data> >, \ + mlc::or_< mlc::ret_found_in_< NAMESPACE::default_case_<context, data> >, \ + typename protected_in_< NAMESPACE::default_case_<context, data> >::is_found > >, \ + mlc::xor_< mlc::ret_found_in_< NAMESPACE::default_case_<context, data> >, \ + typename protected_in_< NAMESPACE::default_case_<context, data> >::is_found > >, \ + mlc::ERROR::A_default_case_STATEMENT_IN_A_switch_SHOULD_NOT_HAVE_BOTH_A_ret_AND_A_protected >, \ + \ + private mlc::assert_< mlc::implies_< typename protected_in_< NAMESPACE::default_case_<context, data> >::is_found, \ + typename protected_in_< NAMESPACE::default_case_<context, data> >::is_found_with_ret >, \ + mlc::ERROR::THE_protected_PART_OF_A_default_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret > \ + \ { \ typedef NAMESPACE::default_case_<context, data> case_t; \ typedef typename mlc::if_<mlc_is_a(case_t, mlc::undefined), \ @@ -154,14 +256,19 @@ template <typename use, typename context, typename data, unsigned i> \ struct handle_case_ <use, context, data, i, 0, 0> \ \ - : private mlc::assert_< mlc::implies_< mlc_is_not_a(mlc_comma_2(NAMESPACE::case_<context, data, i>), \ - mlc::undefined), \ + : private mlc::assert_< mlc::implies_< mlc::is_defined_< NAMESPACE::case_<context, data, i> >, \ mlc_is_a(mlc_comma_2(NAMESPACE::case_<context, data, i>), \ mlc::where_) >, \ - mlc::ERROR::A_case_STATEMENT_SHOULD_DERIVE_FROM_mlc_where_ > \ + mlc::ERROR::A_case_STATEMENT_SHOULD_DERIVE_FROM_mlc_where_ >, \ + \ + private mlc::assert_< mlc::is_defined_< NAMESPACE::default_case_<context, data> >, \ + mlc::WARNING::NO_default_case_STATEMENT_HAS_BEEN_DEFINED > \ + \ { \ typedef handle_default_case_<use, context, data> handle_t; \ - typedef typename handle_t::ret ret; \ + typedef typename mlc::if_< mlc::is_defined_< NAMESPACE::default_case_<context, data> >, \ + typename handle_t::ret, \ + mlc::none >::ret ret; \ }; \ \ \ @@ -177,12 +284,31 @@ mlc::ERROR::A_case_STATEMENT_SHOULD_DERIVE_FROM_mlc_where_ >, \ \ private mlc::assert_< mlc::implies_< mlc::and_< mlc::eq_<use, mlc::internal::a_switch_case>, \ - mlc_is_not_a(mlc_comma_2(NAMESPACE::case_<context, data, i>), \ - mlc::undefined) >, \ - mlc::ret_found_in_< NAMESPACE::case_<context, data, i> > >, \ - mlc::ERROR::A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret > \ + mlc::is_defined_< NAMESPACE::case_<context, data, i> > >, \ + mlc::or_< mlc::ret_found_in_< NAMESPACE::case_<context, data, i> >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found > >, \ + mlc::ERROR::A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_EITHER_A_ret_OR_A_protected >, \ + \ + private mlc::assert_< mlc::implies_< mlc::and_list_< mlc::eq_<use, mlc::internal::a_switch_case>, \ + mlc::is_defined_< NAMESPACE::case_<context, data, i> >, \ + mlc::or_< mlc::ret_found_in_< NAMESPACE::case_<context, data, i> >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found > >, \ + mlc::xor_< mlc::ret_found_in_< NAMESPACE::case_<context, data, i> >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found > >, \ + mlc::ERROR::A_case_STATEMENT_IN_A_switch_SHOULD_NOT_HAVE_BOTH_A_ret_AND_A_protected >, \ + \ + private mlc::assert_< mlc::implies_< mlc::and_list_< mlc::eq_<use, mlc::internal::a_switch_case>, \ + mlc::is_defined_< NAMESPACE::case_<context, data, i> >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found_with_ret >, \ + mlc::ERROR::THE_protected_PART_OF_A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret > \ { \ - typedef NAMESPACE::case_<context, data, i> ret; \ + typedef NAMESPACE::case_<context, data, i> case_t; \ + typedef typename protected_in_<case_t>::the protected_case_t; \ + \ + typedef typename mlc::if_< mlc::is_found_<protected_case_t>, \ + protected_case_t, \ + case_t >::ret ret; \ }; \ \ \ @@ -198,10 +324,24 @@ mlc::ERROR::A_case_STATEMENT_SHOULD_DERIVE_FROM_mlc_where_ >, \ \ private mlc::assert_< mlc::implies_< mlc::and_< mlc::eq_<use, mlc::internal::a_switch_case>, \ - mlc_is_not_a(mlc_comma_2(NAMESPACE::case_<context, data, i>), \ - mlc::undefined) >, \ - mlc::ret_found_in_< NAMESPACE::case_<context, data, i> > >, \ - mlc::ERROR::A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret > \ + mlc::is_defined_< NAMESPACE::case_<context, data, i> > >, \ + mlc::or_< mlc::ret_found_in_< NAMESPACE::case_<context, data, i> >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found > >, \ + mlc::ERROR::A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_EITHER_A_ret_OR_A_protected >, \ + \ + private mlc::assert_< mlc::implies_< mlc::and_list_< mlc::eq_<use, mlc::internal::a_switch_case>, \ + mlc::is_defined_< NAMESPACE::case_<context, data, i> >, \ + mlc::or_< mlc::ret_found_in_< NAMESPACE::case_<context, data, i> >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found > >, \ + mlc::xor_< mlc::ret_found_in_< NAMESPACE::case_<context, data, i> >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found > >, \ + mlc::ERROR::A_case_STATEMENT_IN_A_switch_SHOULD_NOT_HAVE_BOTH_A_ret_AND_A_protected >, \ + \ + private mlc::assert_< mlc::implies_< mlc::and_list_< mlc::eq_<use, mlc::internal::a_switch_case>, \ + mlc::is_defined_< NAMESPACE::case_<context, data, i> >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found >, \ + typename protected_in_< NAMESPACE::case_<context, data, i> >::is_found_with_ret >, \ + mlc::ERROR::THE_protected_PART_OF_A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret > \ { \ typedef mlc_is_a(mlc_comma_2(NAMESPACE::case_<context, data, i+1>), \ mlc::case_selected) next_case_is_selected; \ Index: mlc/cmp.hh --- mlc/cmp.hh (revision 446) +++ mlc/cmp.hh (working copy) @@ -33,23 +33,45 @@ # include <mlc/logic.hh> -/// Macros mlc_eq and mlc_neq. + +/// \{ +/// Macros mlc_eq(T1, T2) and mlc_neq(T1, T2). + # define mlc_eq( T1, T2) mlc::eq_ <T1, T2> # define mlc_neq(T1, T2) mlc::neq_<T1, T2> +/// \} + + + +/// \{ +/// Macros mlc_something(T) corresponding to mlc::something_<T>. + +# define mlc_is_found(T) mlc::is_found_<T> +# define mlc_is_not_found(T) mlc::is_not_found_<T> + +# define mlc_is_undefined(T) mlc::is_undefined_<T> +# define mlc_is_defined(T) mlc::is_defined_<T> + +# define mlc_is_ok(T) mlc::is_ok_<T> +# define mlc_is_not_ok(T) mlc::is_not_ok_<T> + +/// \} + + namespace mlc { /// Check whether \a T is a mlc::abstract::value. template <typename T> - struct is_value : public mlc_is_a(T, mlc::abstract::value) + struct is_value : public mlc_is_a(T, mlc::abstract::value)::bexpr { }; /// Check whether \a T is not a mlc::abstract::value. template <typename T> - struct is_not_value : public not_<mlc_is_a(T, mlc::abstract::value)> + struct is_not_value : public not_<mlc_is_a(T, mlc::abstract::value)>::bexpr { }; @@ -71,6 +93,8 @@ }; /// \} + + /// Inequality test between a couple of types. /// \{ template <typename T1, typename T2> @@ -95,24 +119,48 @@ /// Shortcuts for comparison with mlc::not_found. /// \{ template <typename T> - struct is_found : public neq_<T, not_found> + struct is_not_found_ : public mlc_is_a(T, mlc::not_found)::bexpr { }; template <typename T> - struct is_not_found : public neq_<T, not_found> + struct is_found_ : public mlc_is_not_a(T, mlc::not_found)::bexpr + { + }; + /// \} + + + /// Shortcuts for testing inheritance from mlc::undefined. + /// \{ + template <typename T> + struct is_undefined_ : public mlc_is_a(T, mlc::undefined)::bexpr + { + }; + + template <typename T> + struct is_defined_ : public mlc_is_not_a(T, mlc::undefined)::bexpr { }; /// \} /// Check whether a type is a sound (supposedly before using it). + /// \{ + template <typename T> + struct is_not_ok_ : public or_list_< is_not_found_<T>, + is_undefined_<T>, + mlc_is_a(T, mlc::not_ok) >::bexpr + { + }; + template <typename T> - struct is_ok : public and_< neq_<T, not_found>, - and_< neq_<T, not_ok>, - neq_<T, undefined > > > + struct is_ok_ : public and_list_< is_found_<T>, + is_defined_<T>, + mlc_is_not_a(T, mlc::not_ok) >::bexpr { }; + /// \} + } // end of namespace mlc

1 0

proto-1.0 445: Add GPL to trunk.
by Nicolas Widynski 30 Mar '06

30 Mar '06

https://svn/svn/oln/prototypes/proto-1.0 Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Add GPL to trunk. * COPYING: Modify FDL to Gnu General Public License. COPYING | 721 +++++++++++++++++++++++++++++----------------------------------- 1 file changed, 332 insertions(+), 389 deletions(-) Index: COPYING --- COPYING (revision 444) +++ COPYING (working copy) @@ -1,397 +1,340 @@ -GNU Free Documentation License - Version 1.2, November 2002 + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 - - Copyright (C) 2000,2001,2002,2006 Free Software Foundation, Inc. + Copyright (C) 1989, 1991, 2006 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. + Preamble -0. PREAMBLE - -The purpose of this License is to make a manual, textbook, or other -functional and useful document "free" in the sense of freedom: to -assure everyone the effective freedom to copy and redistribute it, -with or without modifying it, either commercially or noncommercially. -Secondarily, this License preserves for the author and publisher a way -to get credit for their work, while not being considered responsible -for modifications made by others. - -This License is a kind of "copyleft", which means that derivative -works of the document must themselves be free in the same sense. It -complements the GNU General Public License, which is a copyleft -license designed for free software. - -We have designed this License in order to use it for manuals for free -software, because free software needs free documentation: a free -program should come with manuals providing the same freedoms that the -software does. But this License is not limited to software manuals; -it can be used for any textual work, regardless of subject matter or -whether it is published as a printed book. We recommend this License -principally for works whose purpose is instruction or reference. - - -1. APPLICABILITY AND DEFINITIONS - -This License applies to any manual or other work, in any medium, that -contains a notice placed by the copyright holder saying it can be -distributed under the terms of this License. Such a notice grants a -world-wide, royalty-free license, unlimited in duration, to use that -work under the conditions stated herein. The "Document", below, -refers to any such manual or work. Any member of the public is a -licensee, and is addressed as "you". You accept the license if you -copy, modify or distribute the work in a way requiring permission -under copyright law. - -A "Modified Version" of the Document means any work containing the -Document or a portion of it, either copied verbatim, or with -modifications and/or translated into another language. - -A "Secondary Section" is a named appendix or a front-matter section of -the Document that deals exclusively with the relationship of the -publishers or authors of the Document to the Document's overall subject -(or to related matters) and contains nothing that could fall directly -within that overall subject. (Thus, if the Document is in part a -textbook of mathematics, a Secondary Section may not explain any -mathematics.) The relationship could be a matter of historical -connection with the subject or with related matters, or of legal, -commercial, philosophical, ethical or political position regarding -them. - -The "Invariant Sections" are certain Secondary Sections whose titles -are designated, as being those of Invariant Sections, in the notice -that says that the Document is released under this License. If a -section does not fit the above definition of Secondary then it is not -allowed to be designated as Invariant. The Document may contain zero -Invariant Sections. If the Document does not identify any Invariant -Sections then there are none. - -The "Cover Texts" are certain short passages of text that are listed, -as Front-Cover Texts or Back-Cover Texts, in the notice that says that -the Document is released under this License. A Front-Cover Text may -be at most 5 words, and a Back-Cover Text may be at most 25 words. - -A "Transparent" copy of the Document means a machine-readable copy, -represented in a format whose specification is available to the -general public, that is suitable for revising the document -straightforwardly with generic text editors or (for images composed of -pixels) generic paint programs or (for drawings) some widely available -drawing editor, and that is suitable for input to text formatters or -for automatic translation to a variety of formats suitable for input -to text formatters. A copy made in an otherwise Transparent file -format whose markup, or absence of markup, has been arranged to thwart -or discourage subsequent modification by readers is not Transparent. -An image format is not Transparent if used for any substantial amount -of text. A copy that is not "Transparent" is called "Opaque". - -Examples of suitable formats for Transparent copies include plain -ASCII without markup, Texinfo input format, LaTeX input format, SGML -or XML using a publicly available DTD, and standard-conforming simple -HTML, PostScript or PDF designed for human modification. Examples of -transparent image formats include PNG, XCF and JPG. Opaque formats -include proprietary formats that can be read and edited only by -proprietary word processors, SGML or XML for which the DTD and/or -processing tools are not generally available, and the -machine-generated HTML, PostScript or PDF produced by some word -processors for output purposes only. - -The "Title Page" means, for a printed book, the title page itself, -plus such following pages as are needed to hold, legibly, the material -this License requires to appear in the title page. For works in -formats which do not have any title page as such, "Title Page" means -the text near the most prominent appearance of the work's title, -preceding the beginning of the body of the text. - -A section "Entitled XYZ" means a named subunit of the Document whose -title either is precisely XYZ or contains XYZ in parentheses following -text that translates XYZ in another language. (Here XYZ stands for a -specific section name mentioned below, such as "Acknowledgements", -"Dedications", "Endorsements", or "History".) To "Preserve the Title" -of such a section when you modify the Document means that it remains a -section "Entitled XYZ" according to this definition. - -The Document may include Warranty Disclaimers next to the notice which -states that this License applies to the Document. These Warranty -Disclaimers are considered to be included by reference in this -License, but only as regards disclaiming warranties: any other -implication that these Warranty Disclaimers may have is void and has -no effect on the meaning of this License. - - -2. VERBATIM COPYING - -You may copy and distribute the Document in any medium, either -commercially or noncommercially, provided that this License, the -copyright notices, and the license notice saying this License applies -to the Document are reproduced in all copies, and that you add no other -conditions whatsoever to those of this License. You may not use -technical measures to obstruct or control the reading or further -copying of the copies you make or distribute. However, you may accept -compensation in exchange for copies. If you distribute a large enough -number of copies you must also follow the conditions in section 3. - -You may also lend copies, under the same conditions stated above, and -you may publicly display copies. - - -3. COPYING IN QUANTITY - -If you publish printed copies (or copies in media that commonly have -printed covers) of the Document, numbering more than 100, and the -Document's license notice requires Cover Texts, you must enclose the -copies in covers that carry, clearly and legibly, all these Cover -Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on -the back cover. Both covers must also clearly and legibly identify -you as the publisher of these copies. The front cover must present -the full title with all words of the title equally prominent and -visible. You may add other material on the covers in addition. -Copying with changes limited to the covers, as long as they preserve -the title of the Document and satisfy these conditions, can be treated -as verbatim copying in other respects. - -If the required texts for either cover are too voluminous to fit -legibly, you should put the first ones listed (as many as fit -reasonably) on the actual cover, and continue the rest onto adjacent -pages. - -If you publish or distribute Opaque copies of the Document numbering -more than 100, you must either include a machine-readable Transparent -copy along with each Opaque copy, or state in or with each Opaque copy -a computer-network location from which the general network-using -public has access to download using public-standard network protocols -a complete Transparent copy of the Document, free of added material. -If you use the latter option, you must take reasonably prudent steps, -when you begin distribution of Opaque copies in quantity, to ensure -that this Transparent copy will remain thus accessible at the stated -location until at least one year after the last time you distribute an -Opaque copy (directly or through your agents or retailers) of that -edition to the public. - -It is requested, but not required, that you contact the authors of the -Document well before redistributing any large number of copies, to give -them a chance to provide you with an updated version of the Document. - - -4. MODIFICATIONS - -You may copy and distribute a Modified Version of the Document under -the conditions of sections 2 and 3 above, provided that you release -the Modified Version under precisely this License, with the Modified -Version filling the role of the Document, thus licensing distribution -and modification of the Modified Version to whoever possesses a copy -of it. In addition, you must do these things in the Modified Version: - -A. Use in the Title Page (and on the covers, if any) a title distinct - from that of the Document, and from those of previous versions - (which should, if there were any, be listed in the History section - of the Document). You may use the same title as a previous version - if the original publisher of that version gives permission. -B. List on the Title Page, as authors, one or more persons or entities - responsible for authorship of the modifications in the Modified - Version, together with at least five of the principal authors of the - Document (all of its principal authors, if it has fewer than five), - unless they release you from this requirement. -C. State on the Title page the name of the publisher of the - Modified Version, as the publisher. -D. Preserve all the copyright notices of the Document. -E. Add an appropriate copyright notice for your modifications - adjacent to the other copyright notices. -F. Include, immediately after the copyright notices, a license notice - giving the public permission to use the Modified Version under the - terms of this License, in the form shown in the Addendum below. -G. Preserve in that license notice the full lists of Invariant Sections - and required Cover Texts given in the Document's license notice. -H. Include an unaltered copy of this License. -I. Preserve the section Entitled "History", Preserve its Title, and add - to it an item stating at least the title, year, new authors, and - publisher of the Modified Version as given on the Title Page. If - there is no section Entitled "History" in the Document, create one - stating the title, year, authors, and publisher of the Document as - given on its Title Page, then add an item describing the Modified - Version as stated in the previous sentence. -J. Preserve the network location, if any, given in the Document for - public access to a Transparent copy of the Document, and likewise - the network locations given in the Document for previous versions - it was based on. These may be placed in the "History" section. - You may omit a network location for a work that was published at - least four years before the Document itself, or if the original - publisher of the version it refers to gives permission. -K. For any section Entitled "Acknowledgements" or "Dedications", - Preserve the Title of the section, and preserve in the section all - the substance and tone of each of the contributor acknowledgements - and/or dedications given therein. -L. Preserve all the Invariant Sections of the Document, - unaltered in their text and in their titles. Section numbers - or the equivalent are not considered part of the section titles. -M. Delete any section Entitled "Endorsements". Such a section - may not be included in the Modified Version. -N. Do not retitle any existing section to be Entitled "Endorsements" - or to conflict in title with any Invariant Section. -O. Preserve any Warranty Disclaimers. - -If the Modified Version includes new front-matter sections or -appendices that qualify as Secondary Sections and contain no material -copied from the Document, you may at your option designate some or all -of these sections as invariant. To do this, add their titles to the -list of Invariant Sections in the Modified Version's license notice. -These titles must be distinct from any other section titles. - -You may add a section Entitled "Endorsements", provided it contains -nothing but endorsements of your Modified Version by various -parties--for example, statements of peer review or that the text has -been approved by an organization as the authoritative definition of a -standard. - -You may add a passage of up to five words as a Front-Cover Text, and a -passage of up to 25 words as a Back-Cover Text, to the end of the list -of Cover Texts in the Modified Version. Only one passage of -Front-Cover Text and one of Back-Cover Text may be added by (or -through arrangements made by) any one entity. If the Document already -includes a cover text for the same cover, previously added by you or -by arrangement made by the same entity you are acting on behalf of, -you may not add another; but you may replace the old one, on explicit -permission from the previous publisher that added the old one. - -The author(s) and publisher(s) of the Document do not by this License -give permission to use their names for publicity for or to assert or -imply endorsement of any Modified Version. - - -5. COMBINING DOCUMENTS - -You may combine the Document with other documents released under this -License, under the terms defined in section 4 above for modified -versions, provided that you include in the combination all of the -Invariant Sections of all of the original documents, unmodified, and -list them all as Invariant Sections of your combined work in its -license notice, and that you preserve all their Warranty Disclaimers. - -The combined work need only contain one copy of this License, and -multiple identical Invariant Sections may be replaced with a single -copy. If there are multiple Invariant Sections with the same name but -different contents, make the title of each such section unique by -adding at the end of it, in parentheses, the name of the original -author or publisher of that section if known, or else a unique number. -Make the same adjustment to the section titles in the list of -Invariant Sections in the license notice of the combined work. - -In the combination, you must combine any sections Entitled "History" -in the various original documents, forming one section Entitled -"History"; likewise combine any sections Entitled "Acknowledgements", -and any sections Entitled "Dedications". You must delete all sections -Entitled "Endorsements". - - -6. COLLECTIONS OF DOCUMENTS - -You may make a collection consisting of the Document and other documents -released under this License, and replace the individual copies of this -License in the various documents with a single copy that is included in -the collection, provided that you follow the rules of this License for -verbatim copying of each of the documents in all other respects. - -You may extract a single document from such a collection, and distribute -it individually under this License, provided you insert a copy of this -License into the extracted document, and follow this License in all -other respects regarding verbatim copying of that document. - - -7. AGGREGATION WITH INDEPENDENT WORKS - -A compilation of the Document or its derivatives with other separate -and independent documents or works, in or on a volume of a storage or -distribution medium, is called an "aggregate" if the copyright -resulting from the compilation is not used to limit the legal rights -of the compilation's users beyond what the individual works permit. -When the Document is included in an aggregate, this License does not -apply to the other works in the aggregate which are not themselves -derivative works of the Document. - -If the Cover Text requirement of section 3 is applicable to these -copies of the Document, then if the Document is less than one half of -the entire aggregate, the Document's Cover Texts may be placed on -covers that bracket the Document within the aggregate, or the -electronic equivalent of covers if the Document is in electronic form. -Otherwise they must appear on printed covers that bracket the whole -aggregate. - - -8. TRANSLATION - -Translation is considered a kind of modification, so you may -distribute translations of the Document under the terms of section 4. -Replacing Invariant Sections with translations requires special -permission from their copyright holders, but you may include -translations of some or all Invariant Sections in addition to the -original versions of these Invariant Sections. You may include a -translation of this License, and all the license notices in the -Document, and any Warranty Disclaimers, provided that you also include -the original English version of this License and the original versions -of those notices and disclaimers. In case of a disagreement between -the translation and the original version of this License or a notice -or disclaimer, the original version will prevail. - -If a section in the Document is Entitled "Acknowledgements", -"Dedications", or "History", the requirement (section 4) to Preserve -its Title (section 1) will typically require changing the actual -title. - - -9. TERMINATION - -You may not copy, modify, sublicense, or distribute the Document except -as expressly provided for under this License. Any other attempt to -copy, modify, sublicense or distribute the Document is void, and will -automatically terminate your rights under this License. However, -parties who have received copies, or rights, from you under this -License will not have their licenses terminated so long as such + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such parties remain in full compliance. - -10. FUTURE REVISIONS OF THIS LICENSE - -The Free Software Foundation may publish new, revised versions -of the GNU Free Documentation License from time to time. Such new -versions will be similar in spirit to the present version, but may -differ in detail to address new problems or concerns. See -http://www.gnu.org/copyleft/. - -Each version of the License is given a distinguishing version number. -If the Document specifies that a particular numbered version of this -License "or any later version" applies to it, you have the option of -following the terms and conditions either of that specified version or -of any later version that has been published (not as a draft) by the -Free Software Foundation. If the Document does not specify a version -number of this License, you may choose any version ever published (not -as a draft) by the Free Software Foundation. - - -ADDENDUM: How to use this License for your documents - -To use this License in a document you have written, include a copy of -the License in the document and put the following copyright and -license notices just after the title page: - - Copyright (c) YEAR YOUR NAME. - Permission is granted to copy, distribute and/or modify this document - under the terms of the GNU Free Documentation License, Version 1.2 - or any later version published by the Free Software Foundation; - with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. - A copy of the license is included in the section entitled "GNU - Free Documentation License". - -If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, -replace the "with...Texts." line with this: - - with the Invariant Sections being LIST THEIR TITLES, with the - Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. - -If you have Invariant Sections without Cover Texts, or some other -combination of the three, merge those two alternatives to suit the -situation. - -If your document contains nontrivial examples of program code, we -recommend releasing these examples in parallel under your choice of -free software license, such as the GNU General Public License, -to permit their use in free software. \ No newline at end of file + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program 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 program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License.

1 0

444: Remove remaining dependencies between Boolean values and exprs.
by Thierry Geraud 27 Mar '06

27 Mar '06

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Remove remaining dependencies between Boolean values and exprs. * mlc/bool.hh (bool_): Remove inheritance from bexpr_is_. * mlc/bexpr.hh (bexpr_is_): Rename as... (bexpr_): ...this. (bexpr_::bexpr): New typedef so that bexprs can be simplified. * tests/if.cc: Update. * mlc/logic.hh: Add macros; add static checks; update. * mlc/if.hh: Add static check. * mlc/implies.hh: Add static check and update. * mlc/abort.hh: Update. * mlc/is_a.hh (where_): Add static check. Update. * mlc/case.hh: Update. * mlc/cmp.hh: Update. mlc/abort.hh | 2 mlc/bexpr.hh | 63 ++++++++--------- mlc/bool.hh | 3 mlc/case.hh | 13 ++- mlc/cmp.hh | 8 +- mlc/if.hh | 9 ++ mlc/implies.hh | 29 +++++--- mlc/is_a.hh | 10 +- mlc/logic.hh | 201 +++++++++++++++++++++++++++++++++++++++++++-------------- tests/if.cc | 4 - 10 files changed, 235 insertions(+), 107 deletions(-) Index: tests/if.cc --- tests/if.cc (revision 443) +++ tests/if.cc (working copy) @@ -10,9 +10,9 @@ int main() { - typedef mlc_if_(mlc::true_, alpha, beta) x; + typedef mlc_if_(mlc::bexpr_<true>, alpha, beta) x; mlc::assert_< mlc_eq(x, alpha) >::check(); - typedef mlc_if_(mlc::false_, gamma, delta) y; + typedef mlc_if_(mlc::bexpr_<false>, gamma, delta) y; mlc::assert_< mlc_eq(y, delta) >::check(); } Index: mlc/bool.hh --- mlc/bool.hh (revision 443) +++ mlc/bool.hh (working copy) @@ -57,8 +57,7 @@ */ template <bool b> - struct bool_ : public bexpr_is_, - public abstract::boolean + struct bool_ : public abstract::boolean { /*! \typedef type Index: mlc/logic.hh --- mlc/logic.hh (revision 443) +++ mlc/logic.hh (working copy) @@ -28,26 +28,71 @@ #ifndef METALIC_LOGIC_HH # define METALIC_LOGIC_HH -# include <mlc/bool.hh> # include <mlc/bexpr.hh> # include <mlc/assert.hh> +# include <mlc/is_a.hh> + + + + +/// Macros corresponding to binary logic Boolean expressions. +/// \{ + +# define mlc_and(L, R) mlc::and_ < L, R > +# define mlc_nand(L, R) mlc::nand_< L, R > +# define mlc_or(L, R) mlc::or_ < L, R > +# define mlc_nor(L, R) mlc::nor_ < L, R > +# define mlc_xor(L, R) mlc::xor_ < L, R > +# define mlc_xnor(L, R) mlc::xnor_< L, R > + +/// \} + namespace mlc { + namespace ERROR + { + + struct PARAMETER_OF_mlc_not_SHOULD_BE_A_BEXPR; + + struct FIRST_PARAMETER_OF_mlc_and_SHOULD_BE_A_BEXPR; + struct FIRST_PARAMETER_OF_mlc_nand_SHOULD_BE_A_BEXPR; + struct FIRST_PARAMETER_OF_mlc_or_SHOULD_BE_A_BEXPR; + struct FIRST_PARAMETER_OF_mlc_nor_SHOULD_BE_A_BEXPR; + struct FIRST_PARAMETER_OF_mlc_xor_SHOULD_BE_A_BEXPR; + struct FIRST_PARAMETER_OF_mlc_xnor_SHOULD_BE_A_BEXPR; + + struct SECOND_PARAMETER_OF_mlc_and_SHOULD_BE_A_BEXPR; + struct SECOND_PARAMETER_OF_mlc_nand_SHOULD_BE_A_BEXPR; + struct SECOND_PARAMETER_OF_mlc_or_SHOULD_BE_A_BEXPR; + struct SECOND_PARAMETER_OF_mlc_nor_SHOULD_BE_A_BEXPR; + struct SECOND_PARAMETER_OF_mlc_xor_SHOULD_BE_A_BEXPR; + struct SECOND_PARAMETER_OF_mlc_xnor_SHOULD_BE_A_BEXPR; + + } // end of mlc::ERROR + + + /*! \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 bexpr_is_<( !mlc_bool(T) )> + + : private assert_< mlc_is_a(T, mlc::abstract::bexpr), + mlc::ERROR::PARAMETER_OF_mlc_not_SHOULD_BE_A_BEXPR >, + + public bexpr_<( !mlc_bool(T) )> {}; + /*! \class mlc::and_<L,R> ** ** Logical binary 'and' operator on a couple of Boolean expression @@ -55,12 +100,21 @@ ** ** \see mlc::and_list_<..> */ + template <typename L, typename R> struct and_ - : public bexpr_is_<( mlc_bool(L) && mlc_bool(R) )> + + : private assert_< mlc_is_a(L, mlc::abstract::bexpr), + mlc::ERROR::FIRST_PARAMETER_OF_mlc_and_SHOULD_BE_A_BEXPR >, + + private assert_< mlc_is_a(R, mlc::abstract::bexpr), + mlc::ERROR::SECOND_PARAMETER_OF_mlc_and_SHOULD_BE_A_BEXPR >, + + public bexpr_<( mlc_bool(L) && mlc_bool(R) )> {}; + /*! \class mlc::nand_<L,R> ** ** Logical binary 'not and' operator on a couple of Boolean @@ -68,12 +122,21 @@ ** ** Design note: an equivalent is mlc::not_< mlc::and_<L,R> >. */ + template <typename L, typename R> struct nand_ - : public bexpr_is_<( !(mlc_bool(L) && mlc_bool(R)) )> + + : private assert_< mlc_is_a(L, mlc::abstract::bexpr), + mlc::ERROR::FIRST_PARAMETER_OF_mlc_nand_SHOULD_BE_A_BEXPR >, + + private assert_< mlc_is_a(R, mlc::abstract::bexpr), + mlc::ERROR::SECOND_PARAMETER_OF_mlc_nand_SHOULD_BE_A_BEXPR >, + + public bexpr_<( !(mlc_bool(L) && mlc_bool(R)) )> {}; + /*! \class mlc::or_<L,R> ** ** Logical binary 'or' operator on a couple of Boolean expression @@ -81,12 +144,21 @@ ** ** \see mlc::or_list_<..> */ + template <typename L, typename R> struct or_ - : public bexpr_is_<( mlc_bool(L) || mlc_bool(R) )> + + : private assert_< mlc_is_a(L, mlc::abstract::bexpr), + mlc::ERROR::FIRST_PARAMETER_OF_mlc_or_SHOULD_BE_A_BEXPR >, + + private assert_< mlc_is_a(R, mlc::abstract::bexpr), + mlc::ERROR::SECOND_PARAMETER_OF_mlc_or_SHOULD_BE_A_BEXPR >, + + public bexpr_<( mlc_bool(L) || mlc_bool(R) )> {}; + /*! \class mlc::nor_<L,R> ** ** Logical binary 'not or' operator on a couple of Boolean @@ -94,20 +166,37 @@ ** ** Design note: an equivalent is mlc::not_< mlc::or_<L,R> >. */ + template <typename L, typename R> struct nor_ - : public bexpr_is_<( !(mlc_bool(L) || mlc_bool(R)) )> + + : private assert_< mlc_is_a(L, mlc::abstract::bexpr), + mlc::ERROR::FIRST_PARAMETER_OF_mlc_nor_SHOULD_BE_A_BEXPR >, + + private assert_< mlc_is_a(R, mlc::abstract::bexpr), + mlc::ERROR::SECOND_PARAMETER_OF_mlc_nor_SHOULD_BE_A_BEXPR >, + + public bexpr_<( !(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 bexpr_is_<( mlc_bool(L) != mlc_bool(R) )> + + : private assert_< mlc_is_a(L, mlc::abstract::bexpr), + mlc::ERROR::FIRST_PARAMETER_OF_mlc_xor_SHOULD_BE_A_BEXPR >, + + private assert_< mlc_is_a(R, mlc::abstract::bexpr), + mlc::ERROR::SECOND_PARAMETER_OF_mlc_xor_SHOULD_BE_A_BEXPR >, + + public bexpr_<( mlc_bool(L) != mlc_bool(R) )> {}; @@ -116,9 +205,17 @@ ** 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 bexpr_is_<( !(mlc_bool(L) != mlc_bool(R)) )> + + : private assert_< mlc_is_a(L, mlc::abstract::bexpr), + mlc::ERROR::FIRST_PARAMETER_OF_mlc_xnor_SHOULD_BE_A_BEXPR >, + + private assert_< mlc_is_a(R, mlc::abstract::bexpr), + mlc::ERROR::SECOND_PARAMETER_OF_mlc_xnor_SHOULD_BE_A_BEXPR >, + + public bexpr_<( !(mlc_bool(L) != mlc_bool(R)) )> {}; @@ -131,21 +228,27 @@ // FIXME: doc template <typename A> - struct is_bexpr_or_none_ : public true_ // FIXME: pb using mlc_is_a because of circular deps + struct is_bexpr_or_none_ + : public mlc_is_a(A, mlc::abstract::bexpr) { }; + template <> + struct is_bexpr_or_none_ < none > + : public bexpr_<true> + { + }; - // va_eval_ + // va_bexpr_ template <typename A> - struct va_eval_ + struct va_bexpr_ { - typedef typename A::eval ret; + typedef typename A::bexpr ret; }; template <> - struct va_eval_ <none> + struct va_bexpr_ <none> { typedef none ret; }; @@ -155,17 +258,17 @@ template <typename A1, typename A2> struct or_list_2_ - : public or_<A1, A2>::eval + : public or_<A1, A2> {}; template <> struct or_list_2_ <none, none> - : public false_ + : public bexpr_<false> {}; template <typename A1> struct or_list_2_ <A1, none> - : public A1 + : public A1::bexpr {}; template <typename A2> @@ -175,13 +278,13 @@ template <typename A1, typename A2, typename A3, typename A4> struct or_list_4_ - : public or_list_2_< typename or_list_2_<A1, A2>::eval, - typename or_list_2_<A3, A4>::eval >::eval + : public or_list_2_< typename or_list_2_<A1, A2>::bexpr, + typename or_list_2_<A3, A4>::bexpr >::bexpr {}; template <> struct or_list_4_ <none, none, none, none> - : public false_ + : public bexpr_<false> {}; // or_list_ @@ -189,8 +292,8 @@ template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> struct or_list_ - : public or_list_2_< typename or_list_4_<A1, A2, A3, A4>::eval, - typename or_list_4_<A5, A6, A7, A8>::eval >::eval + : public or_list_2_< typename or_list_4_<A1, A2, A3, A4>::bexpr, + typename or_list_4_<A5, A6, A7, A8>::bexpr >::bexpr {}; @@ -198,12 +301,12 @@ template <typename A1, typename A2> struct and_list_2_ - : public and_<A1, A2>::eval + : public and_<A1, A2> {}; template <> struct and_list_2_ <none, none> - : public true_ + : public bexpr_<true> {}; template <typename A1> @@ -218,13 +321,13 @@ template <typename A1, typename A2, typename A3, typename A4> struct and_list_4_ - : public and_list_2_< typename and_list_2_<A1, A2>::eval, - typename and_list_2_<A3, A4>::eval >::eval + : public and_list_2_< typename and_list_2_<A1, A2>::bexpr, + typename and_list_2_<A3, A4>::bexpr >::bexpr {}; template <> struct and_list_4_ <none, none, none, none> - : public true_ + : public bexpr_<true> {}; // and_list_ @@ -232,8 +335,8 @@ template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> struct and_list_ - : public and_list_2_< typename and_list_4_<A1, A2, A3, A4>::eval, - typename and_list_4_<A5, A6, A7, A8>::eval >::eval + : public and_list_2_< typename and_list_4_<A1, A2, A3, A4>::bexpr, + typename and_list_4_<A5, A6, A7, A8>::bexpr >::bexpr {}; } // end of mlc::internal @@ -262,7 +365,9 @@ typename A6 = none, typename A7 = none, typename A8 = none> - struct or_list_ : private multiple_assert_< internal::is_bexpr_or_none_<A1>, + struct or_list_ : + + private multiple_assert_< internal::is_bexpr_or_none_<A1>, internal::is_bexpr_or_none_<A2>, internal::is_bexpr_or_none_<A3>, internal::is_bexpr_or_none_<A4>, @@ -270,14 +375,15 @@ internal::is_bexpr_or_none_<A6>, internal::is_bexpr_or_none_<A7>, internal::is_bexpr_or_none_<A8> >, - public internal::or_list_< typename internal::va_eval_<A1>::ret, - typename internal::va_eval_<A2>::ret, - typename internal::va_eval_<A3>::ret, - typename internal::va_eval_<A4>::ret, - typename internal::va_eval_<A5>::ret, - typename internal::va_eval_<A6>::ret, - typename internal::va_eval_<A7>::ret, - typename internal::va_eval_<A8>::ret > + + public internal::or_list_< typename internal::va_bexpr_<A1>::ret, + typename internal::va_bexpr_<A2>::ret, + typename internal::va_bexpr_<A3>::ret, + typename internal::va_bexpr_<A4>::ret, + typename internal::va_bexpr_<A5>::ret, + typename internal::va_bexpr_<A6>::ret, + typename internal::va_bexpr_<A7>::ret, + typename internal::va_bexpr_<A8>::ret > { }; @@ -300,7 +406,9 @@ typename A6 = none, typename A7 = none, typename A8 = none> - struct and_list_ : private multiple_assert_< internal::is_bexpr_or_none_<A1>, + struct and_list_ : + + private multiple_assert_< internal::is_bexpr_or_none_<A1>, internal::is_bexpr_or_none_<A2>, internal::is_bexpr_or_none_<A3>, internal::is_bexpr_or_none_<A4>, @@ -308,14 +416,15 @@ internal::is_bexpr_or_none_<A6>, internal::is_bexpr_or_none_<A7>, internal::is_bexpr_or_none_<A8> >, - public internal::and_list_< typename internal::va_eval_<A1>::ret, - typename internal::va_eval_<A2>::ret, - typename internal::va_eval_<A3>::ret, - typename internal::va_eval_<A4>::ret, - typename internal::va_eval_<A5>::ret, - typename internal::va_eval_<A6>::ret, - typename internal::va_eval_<A7>::ret, - typename internal::va_eval_<A8>::ret > + + public internal::and_list_< typename internal::va_bexpr_<A1>::ret, + typename internal::va_bexpr_<A2>::ret, + typename internal::va_bexpr_<A3>::ret, + typename internal::va_bexpr_<A4>::ret, + typename internal::va_bexpr_<A5>::ret, + typename internal::va_bexpr_<A6>::ret, + typename internal::va_bexpr_<A7>::ret, + typename internal::va_bexpr_<A8>::ret > { }; Index: mlc/if.hh --- mlc/if.hh (revision 443) +++ mlc/if.hh (working copy) @@ -51,6 +51,12 @@ namespace mlc { + namespace ERROR + { + struct FIXME; + + } // end of mlc::ERROR + namespace internal { @@ -89,7 +95,8 @@ template <typename cond_type, typename then_type, typename else_type> struct if_ : // FIXME: enable the static assertion below!!! - private assert_< mlc_is_a(cond_type, mlc::abstract::bexpr) >, + private assert_< mlc_is_a(cond_type, mlc::abstract::bexpr), + mlc::ERROR::FIXME >, public internal::if_ < mlc_bool(cond_type), then_type, else_type > { }; Index: mlc/implies.hh --- mlc/implies.hh (revision 443) +++ mlc/implies.hh (working copy) @@ -29,9 +29,11 @@ # define METALIC_IMPLIES_HH # include <mlc/bexpr.hh> +# include <mlc/assert.hh> +# include <mlc/is_a.hh> -/*! \def mlc_implies(Left_BExpr, Right_BExpr) +/*! \def mlc_implies(L, R) ** ** Macro corresponding to mlc::implies_<L, R>, for use in a template ** context. @@ -39,29 +41,40 @@ ** \see mlc::implies_<L, R> */ -# define mlc_implies(Left_BExpr, Right_BExpr) \ - mlc::bexpr_< typename mlc::implies_<Left_BExpr, Right_BExpr>::ret > - -# define mlc_implies_(Left_BExpr, Right_BExpr) \ - mlc::implies_<Left_BExpr, Right_BExpr>::ret +# define mlc_implies(L, R) mlc::implies_<L, R> namespace mlc { + namespace ERROR + { + struct FIRST_PARAMETER_OF_mlc_implies_SHOULD_BE_A_BEXPR; + struct SECOND_PARAMETER_OF_mlc_implies_SHOULD_BE_A_BEXPR; + + } // end of namespace mlc::ERROR + + /*! \class mlc::implies_<L, R> ** ** Logical implication "L => R" with L and R being Boolean ** expression types. This class is also a Boolean expression type. ** ** Sample use: - ** mlc::implies_< mlc_is_builtin(T), mlc_eq(T, int) >::assert(); + ** mlc::assert_< mlc::implies_< mlc_is_builtin(T), mlc_eq(T, int) > >::check(); ** which means "if T is a buit-in type, it has to be int". */ template <typename L, typename R> struct implies_ - : public mlc::bexpr_is_<( !mlc_bool(L) || mlc_bool(R) )> + + : private assert_< mlc_is_a(L, mlc::abstract::bexpr), + mlc::ERROR::FIRST_PARAMETER_OF_mlc_implies_SHOULD_BE_A_BEXPR >, + + private assert_< mlc_is_a(R, mlc::abstract::bexpr), + mlc::ERROR::SECOND_PARAMETER_OF_mlc_implies_SHOULD_BE_A_BEXPR >, + + public mlc::bexpr_<( !mlc_bool(L) || mlc_bool(R) )> {}; } // end of namespace mlc Index: mlc/abort.hh --- mlc/abort.hh (revision 443) +++ mlc/abort.hh (working copy) @@ -59,7 +59,7 @@ template <typename T> struct always_false_ - : public bexpr_is_<false> + : public bexpr_<false> { protected: always_false_() {} Index: mlc/is_a.hh --- mlc/is_a.hh (revision 443) +++ mlc/is_a.hh (working copy) @@ -108,7 +108,7 @@ template<class T, class U> struct ret - : public mlc::bexpr_is_<( mlc_internal_is_a_result_ )> + : public mlc::bexpr_<( mlc_internal_is_a_result_ )> { }; }; @@ -131,7 +131,7 @@ template<class T, template < class > class U> struct ret - : public mlc::bexpr_is_<( mlc_internal_is_a_result_ )> + : public mlc::bexpr_<( mlc_internal_is_a_result_ )> { }; }; @@ -154,7 +154,7 @@ template<class T, template < class,class > class U> struct ret - : public mlc::bexpr_is_<( mlc_internal_is_a_result_ )> + : public mlc::bexpr_<( mlc_internal_is_a_result_ )> {}; }; @@ -176,7 +176,7 @@ template<class T, template < template < class > class > class U> struct ret - : public mlc::bexpr_is_<( mlc_internal_is_a_result_ )> + : public mlc::bexpr_<( mlc_internal_is_a_result_ )> {}; }; @@ -198,7 +198,7 @@ template<class T, template < template < class,class > class > class U> struct ret - : public mlc::bexpr_is_<( mlc_internal_is_a_result_ )> + : public mlc::bexpr_<( mlc_internal_is_a_result_ )> {}; }; Index: mlc/case.hh --- mlc/case.hh (revision 443) +++ mlc/case.hh (working copy) @@ -28,7 +28,8 @@ #ifndef METALIC_CASE_HH # define METALIC_CASE_HH -# include <mlc/bool.hh> +# include <mlc/bexpr.hh> +# include <mlc/assert.hh> # include <mlc/ret.hh> # include <mlc/is_a.hh> # include <mlc/implies.hh> @@ -64,13 +65,17 @@ struct NO_case_STATEMENT_CAN_BE_SELECTED; struct A_default_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret; struct A_case_STATEMENT_IN_A_switch_SHOULD_HAVE_A_ret; + struct PARAMETER_OF_mlc_where_SHOULD_BE_A_BEXPR; } template <typename bexpr> - struct where_ : public mlc_if_( typename bexpr::eval, - case_selected, - case_not_selected ) + struct where_ : + + private assert_< mlc_is_a(bexpr, mlc::abstract::bexpr), + mlc::ERROR::PARAMETER_OF_mlc_where_SHOULD_BE_A_BEXPR >, + + public mlc_if_( bexpr, case_selected, case_not_selected ) { }; Index: mlc/cmp.hh --- mlc/cmp.hh (revision 443) +++ mlc/cmp.hh (working copy) @@ -60,13 +60,13 @@ template <typename T1, typename T2> struct eq_ : private multiple_assert_< is_not_value<T1>, is_not_value<T2> >, - public bexpr_is_<false> + public bexpr_<false> { }; template <typename T> struct eq_ <T, T> : private assert_< is_not_value<T> >, - public bexpr_is_<true> + public bexpr_<true> { }; /// \} @@ -76,13 +76,13 @@ template <typename T1, typename T2> struct neq_ : private multiple_assert_< is_not_value<T1>, is_not_value<T2> >, - public bexpr_is_<true> + public bexpr_<true> { }; template <typename T> struct neq_ <T, T> : private assert_< is_not_value<T> >, - public bexpr_is_<false> + public bexpr_<false> { }; /// \} Index: mlc/bexpr.hh --- mlc/bexpr.hh (revision 443) +++ mlc/bexpr.hh (working copy) @@ -54,9 +54,9 @@ ** ** When you define a new class for a Boolean expression type, you ** should not directly derive from this class from fom its - ** subclass: bexpr_is_. + ** subclass: bexpr_. ** - ** \see bexpr_is_ + ** \see bexpr_ */ struct bexpr : public type @@ -68,7 +68,7 @@ - /*! \class mlc::bexpr_is_ + /*! \class mlc::bexpr_ ** ** Base class for any class of mlc Boolean expression types. ** When you define a new class for a Boolean expression type, you @@ -77,50 +77,57 @@ ** This class provides the typedef 'eval' which evaluates to either ** mlc::true_ or mlc::false_ the expression. ** - ** \see mlc::bexpr_is_<true>, mlc::bexpr_is_<false> + ** \see mlc::bexpr_<true>, mlc::bexpr_<false> */ - template <bool b> struct bexpr_is_; + template <bool b> struct bexpr_; - /*! \class mlc::bexpr_is_<true> + /*! \class mlc::bexpr_<true> ** - ** Specialization of mlc::bexpr_is_ when b is 'true'. This class + ** Specialization of mlc::bexpr_ when b is 'true'. This class ** provides the typedef member 'is_true' to every Boolean expression ** type that evaluates to true_. ** - ** \see mlc::bexpr_is_, mlc::bexpr_is_<false> + ** \see mlc::bexpr_, mlc::bexpr_<false> */ template <> - struct bexpr_is_ < true > : public abstract::bexpr + struct bexpr_ < true > : public abstract::bexpr { + // FIXME: doc typedef mlc::true_ eval; /*! \typedef is_true ** ** This member is inherited in every Boolean expression type that ** evaluates to true_. Conversely, such member does not appear in - ** bexpr_is_<false> so it does not exist in every Boolean + ** bexpr_<false> so it does not exist in every Boolean ** expression type that evaluates to false_. */ typedef mlc::dummy is_true; + + // FIXME: doc + typedef bexpr_<true> bexpr; }; - /*! \class mlc::bexpr_is_<false> + + /*! \class mlc::bexpr_<false> ** - ** Specialization of mlc::bexpr_is_ when b is 'false'. This class + ** Specialization of mlc::bexpr_ when b is 'false'. This class ** does not provide the typedef member 'is_true' to every Boolean expression ** type that evaluates to false_. ** - ** \see mlc::bexpr_is_, mlc::bexpr_is_<true> + ** \see mlc::bexpr_, mlc::bexpr_<true> */ template <> - struct bexpr_is_ < false > : public abstract::bexpr + struct bexpr_ < false > : public abstract::bexpr { typedef mlc::false_ eval; + + typedef bexpr_<false> bexpr; }; @@ -129,31 +136,19 @@ namespace internal { - /// \class mlc::internal::bool_of_<bexpr> + /// \class mlc::internal::bool_<bexpr> /// \brief Returns the bool value corresponding to a Boolean expression type. /// \note Internal class, don't use it directly. template <typename bexpr> - struct bool_of_ + struct bool_of_bexpr_ // FIXME: commented below to avoid circular dependances // : private assert_< mlc_is_a(bexpr, mlc::abstract::bexpr) > { - // 1) the bexpr evaluates to either mlc::true_ or mlc::false_ - // so the expected result comes from the value of b in - // mlc::bool_ - // 2) retrieving b is performed by the specialization of - // internal::bool_of_ provided few lines below - static const bool ret = internal::bool_of_<typename bexpr::eval>::ret; - }; - - /// \class mlc::internal::bool_of_< mlc::bool_ > - /// \brief Specialization of mlc::internal::bool_of_<bexpr> - /// \note Internal class, don't use it directly. - /// \see mlc::internal::bool_of_<bexpr> - template <bool b> - struct bool_of_ < mlc::bool_ > - { - static const bool ret = b; + // 1) evaluate the bexpr to get either mlc::true_ or mlc::false_ + typedef typename bexpr::eval eval; + // 2) retrieve the Boolean value + static const bool ret = eval::value; }; } // end of namespace mlc::internal @@ -169,10 +164,10 @@ ** Returns the bool value corresponding to a Boolean expression type. ** ** \note Value retrieval is performed by - ** mlc::internal::bool_of_<Bexpr> + ** mlc::internal::bool_of_bexpr_<Bexpr> */ -# define mlc_bool(Bexpr) mlc::internal::bool_of_<Bexpr>::ret +# define mlc_bool(Bexpr) mlc::internal::bool_of_bexpr_<Bexpr>::ret

1 0

443: Add a lot of material for operators (arith, logical, cmp).
by Thierry Geraud 25 Mar '06

25 Mar '06

https://svn.lrde.epita.fr/svn/oln/trunk/extended Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Add a lot of material for operators (arith, logical, cmp). * xtd/cast.hh: Fix doc. * xtd/cfun.hh: New file dedicated to C functions. * xtd/traits.hh: Add a lot of material. * xtd/math/arith.hh: Update. * xtd/ops_expr.hh: Update. * xtd/builtin/traits.hh: Update. * xtd/literal.hh: Add static assertions. * xtd/abstract/fun_expr.hh (nargs): Move to... * xtd/abstract/nary_fun.hh: ...this file. (n): New method. * tests/cfun.cc: New file. * tests/Makefile.am: Update. tests/Makefile.am | 2 tests/cfun.cc | 35 ++++ xtd/abstract/fun_expr.hh | 5 xtd/abstract/nary_fun.hh | 8 xtd/builtin/traits.hh | 114 ++++++++----- xtd/cast.hh | 2 xtd/cfun.hh | 398 +++++++++++++++++++++++++++++++++++++++++++++++ xtd/literal.hh | 14 + xtd/math/arith.hh | 130 +++++++++------ xtd/ops_expr.hh | 107 ++++++++---- xtd/traits.hh | 115 +++++++++++++ 11 files changed, 803 insertions(+), 127 deletions(-) Index: xtd/cast.hh --- xtd/cast.hh (revision 442) +++ xtd/cast.hh (working copy) @@ -96,7 +96,7 @@ ** ** This function mimics the behavior of the method: ** - ** xtd::meta_nary_fun_<1, E>::operator(const A& a) + ** xtd::open_nary_fun_<1, E>::operator(const A& a) ** ** The method is thus turned into a function where E, the ** unary meta function actually is meta_cast_<Dest>. Index: xtd/cfun.hh --- xtd/cfun.hh (revision 0) +++ xtd/cfun.hh (revision 0) @@ -0,0 +1,398 @@ +// Copyright (C) 2002, 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 +// 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 EXTENDED_CFUN_HH +# define EXTENDED_CFUN_HH + +# include <xtd/abstract/plain_nary_fun.hh> +# include <xtd/abstract/meta_nary_fun.hh> + + + + +namespace xtd +{ + + + template <typename F> struct plain_cfun_; // fwd decl + + + template <typename R> + struct fun_traits_< R(*)() > + { + typedef R res_type; + }; + + template <typename R, typename A> + struct fun_traits_< R(*)(A) > + { + typedef R res_type; + typedef A arg_type; + }; + + template <typename R, typename A1, typename A2> + struct fun_traits_< R(*)(A1, A2) > + { + typedef R res_type; + typedef A1 arg1_type; + typedef A2 arg2_type; + }; + + template <typename R, typename A1, typename A2, typename A3> + struct fun_traits_< R(*)(A1, A2, A3) > + { + typedef R res_type; + typedef A1 arg1_type; + typedef A2 arg2_type; + typedef A3 arg3_type; + }; + + + template <typename F> + struct fun_traits_< plain_cfun_<F> > : fun_traits_<F> + { + }; + + + + /*! \class xtd::plain_cfun_< R(*)() > + ** + ** FIXME: doc + */ + + template <typename R> + struct plain_cfun_ < R(*)() > + + : public abstract::plain_nary_fun_< 0, plain_cfun_<R(*)()> > + { + typedef R(*cfun_type)(); + const cfun_type f; + + plain_cfun_(const cfun_type& f) + : f(f) + {} + + R impl_op() const + { + return this->f(); + } + }; + + + template <typename R> + plain_cfun_<R(*)()> mk_plain_fun( R(*f)() ) + { + plain_cfun_<R(*)()> tmp(f); + return tmp; + } + + + + /*! \class xtd::plain_cfun_< R(*)(A) > + ** + ** FIXME: doc + */ + + template <typename R, typename A> + struct plain_cfun_ < R(*)(A) > + + : public abstract::plain_nary_fun_< 1, plain_cfun_<R(*)(A)> > + { + typedef R(*cfun_type)(A); + const cfun_type f; + + plain_cfun_(const cfun_type& f) + : f(f) + {} + + R impl_op(const A& a) const + { + return this->f(a); + } + }; + + + template <typename R, typename A> + plain_cfun_<R(*)(A)> mk_plain_fun( R(*f)(A) ) + { + plain_cfun_<R(*)(A)> tmp(f); + return tmp; + } + + + + + /*! \class xtd::plain_cfun_< R(*)(A1,A2) > + ** + ** FIXME: doc + */ + + template <typename R, typename A1, typename A2> + struct plain_cfun_ < R(*)(A1,A2) > + + : public abstract::plain_nary_fun_< 2, plain_cfun_<R(*)(A1,A2)> > + { + typedef R(*cfun_type)(A1,A2); + const cfun_type f; + + plain_cfun_(const cfun_type& f) + : f(f) + {} + + R impl_op(const A1& a1, const A2& a2) const + { + return this->f(a1, a2); + } + }; + + + template <typename R, typename A1, typename A2> + plain_cfun_<R(*)(A1,A2)> mk_plain_fun( R(*f)(A1,A2) ) + { + plain_cfun_<R(*)(A1,A2)> tmp(f); + return tmp; + } + + + + /*! \class xtd::plain_cfun_< R(*)(A1,A2,A3) > + ** + ** FIXME: doc + */ + + template <typename R, typename A1, typename A2, typename A3> + struct plain_cfun_ < R(*)(A1,A2,A3) > + + : public abstract::plain_nary_fun_< 3, plain_cfun_<R(*)(A1,A2,A3)> > + { + typedef R(*cfun_type)(A1,A2,A3); + const cfun_type f; + + plain_cfun_(const cfun_type& f) + : f(f) + {} + + R impl_op(const A1& a1, const A2& a2, const A3& a3) const + { + return this->f(a1, a2, a3); + } + }; + + + template <typename R, typename A1, typename A2, typename A3> + plain_cfun_<R(*)(A1,A2,A3)> mk_plain_fun( R(*f)(A1,A2,A3) ) + { + plain_cfun_<R(*)(A1,A2,A3)> tmp(f); + return tmp; + } + + + + + + + + + /*! \class xtd::meta_cfun_<F> + ** + ** FIXME: doc + */ + + template <typename F> + struct meta_cfun_; + + + + /*! \class xtd::meta_cfun_< R_(*)() > + ** + ** FIXME: doc + */ + + template <typename R_> + struct res_< meta_cfun_<R_(*)()> > + { + typedef R_ ret; + }; + + template <typename R_> + struct meta_cfun_ < R_(*)() > + + : public abstract::meta_nary_fun_< 0, meta_cfun_<R_(*)()> > + { + typedef R_(*cfun_type)(); + const cfun_type f; + + meta_cfun_(const cfun_type& f) + : f(f) + {} + + R_ impl_calc() const + { + return this->f; + } + }; + + template <typename R> + meta_cfun_<R(*)()> mk_fun( R(*f)() ) + { + meta_cfun_<R(*)()> tmp(f); + return tmp; + } + + + + /*! \class xtd::meta_cfun_< R_(*)(A_) > + ** + ** FIXME: doc + */ + + template <typename R_, typename A_, + typename A> + struct res_< meta_cfun_<R_(*)(A_)>, + A > + { + typedef R_ ret; + }; + + template <typename R_, typename A_> + struct meta_cfun_ < R_(*)(A_) > + + : public abstract::meta_nary_fun_< 1, meta_cfun_<R_(*)(A_)> > + { + typedef R_(*cfun_type)(A_); + const cfun_type f; + + meta_cfun_(const cfun_type& f) + : f(f) + {} + + template <typename A> + R_ impl_calc(const A& a) const + { + // FIXME: check that conversion "A -> A_" exists + return this->f(a); + } + }; + + template <typename R, typename A> + meta_cfun_<R(*)(A)> mk_fun( R(*f)(A) ) + { + meta_cfun_<R(*)(A)> tmp(f); + return tmp; + } + + + + /*! \class xtd::meta_cfun_< R_(*)(A1_,A2_) > + ** + ** FIXME: doc + */ + + template <typename R_, typename A1_, typename A2_, + typename A1, typename A2> + struct res_< meta_cfun_<R_(*)(A1_,A2_)>, + A1, A2 > + { + typedef R_ ret; + }; + + template <typename R_, typename A1_, typename A2_> + struct meta_cfun_ < R_(*)(A1_,A2_) > + + : public abstract::meta_nary_fun_< 2, meta_cfun_<R_(*)(A1_,A2_)> > + { + typedef R_(*cfun_type)(A1_,A2_); + const cfun_type f; + + meta_cfun_(const cfun_type& f) + : f(f) + {} + + template <typename A1, typename A2> + R_ impl_calc(const A1& a1, const A2& a2) const + { + // FIXME: check that conversions "Ai -> Ai_" exist + return this->f(a1, a2); + } + }; + + template <typename R, typename A1, typename A2> + meta_cfun_<R(*)(A1,A2)> mk_fun( R(*f)(A1,A2) ) + { + meta_cfun_<R(*)(A1,A2)> tmp(f); + return tmp; + } + + + + /*! \class xtd::meta_cfun_< R_(*)(A1_,A2_,A3_) > + ** + ** FIXME: doc + */ + + template <typename R_, typename A1_, typename A2_, typename A3_, + typename A1, typename A2, typename A3> + struct res_< meta_cfun_<R_(*)(A1_,A2_,A3_)>, + A1, A2, A3 > + { + typedef R_ ret; + }; + + template <typename R_, typename A1_, typename A2_, typename A3_> + struct meta_cfun_ < R_(*)(A1_,A2_,A3_) > + + : public abstract::meta_nary_fun_< 3, meta_cfun_<R_(*)(A1_,A2_,A3_)> > + { + typedef R_(*cfun_type)(A1_,A2_,A3_); + const cfun_type f; + + meta_cfun_(const cfun_type& f) + : f(f) + {} + + template <typename A1, typename A2, typename A3> + R_ impl_calc(const A1& a1, const A2& a2, const A3& a3) const + { + // FIXME: check that conversions "Ai -> Ai_" exist + return this->f(a1, a2, a3); + } + }; + + template <typename R, typename A1, typename A2, typename A3> + meta_cfun_<R(*)(A1,A2,A3)> mk_fun( R(*f)(A1,A2,A3) ) + { + meta_cfun_<R(*)(A1,A2,A3)> tmp(f); + return tmp; + } + + + +} // end of namespace xtd + + + +#endif // ! EXTENDED_CFUN_HH Index: xtd/math/arith.hh --- xtd/math/arith.hh (revision 442) +++ xtd/math/arith.hh (working copy) @@ -33,68 +33,104 @@ # include <xtd/mfun.hh> +// FIXME: doc -namespace xtd -{ +# define xtd_internal_decl_plain_unary_fun_op(OperatorName, OperatorSymbol) \ + \ + template <typename T> \ + struct plain_##OperatorName##_; \ + \ + template <typename T> \ + struct fun_traits_< plain_##OperatorName##_<T> > \ + { \ + typedef T arg_type; \ + typedef xtd_##OperatorName(T) res_type; \ + }; \ + \ + template <typename T> \ + struct plain_##OperatorName##_ \ + \ + : public abstract::plain_nary_fun_< 1, plain_##OperatorName##_<T> > \ + { \ + typedef plain_##OperatorName##_<T> self; \ + xtd_res(self) impl_op(const T& arg) const \ + { \ + return OperatorSymbol arg; \ + } \ + }; \ + \ + typedef m1fun_<plain_##OperatorName##_> OperatorName##_type; \ + const OperatorName##_type OperatorName; \ + \ + struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n - /*! \class xtd::plain_plus_<T> - ** - ** FIXME: doc - */ - template <typename T1, typename T2> struct plain_plus_; // fwd decl - template <typename T1, typename T2> - struct fun_traits_< plain_plus_<T1, T2> > - { - typedef T1 arg1_type; - typedef T2 arg2_type; - typedef xtd_plus(T1, T2) res_type; - }; +# define xtd_internal_decl_plain_binary_fun_op(OperatorName, OperatorSymbol) \ + \ + template <typename T1, typename T2> \ + struct plain_##OperatorName##_; \ + \ + template <typename T1, typename T2> \ + struct fun_traits_< plain_##OperatorName##_<T1, T2> > \ + { \ + typedef T1 arg1_type; \ + typedef T2 arg2_type; \ + typedef xtd_##OperatorName(T1, T2) res_type; \ + }; \ + \ + template <typename T1, typename T2> \ + struct plain_##OperatorName##_ \ + \ + : public abstract::plain_nary_fun_< 2, plain_##OperatorName##_<T1, T2> > \ + { \ + typedef plain_##OperatorName##_<T1, T2> self; \ + xtd_res(self) impl_op(const T1& arg1, const T2& arg2) const \ + { \ + return arg1 OperatorSymbol arg2; \ + } \ + }; \ + \ + typedef m2fun_<plain_##OperatorName##_> OperatorName##_type; \ + const OperatorName##_type OperatorName; \ + \ + struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n - template <typename T1, typename T2> - struct plain_plus_ : public abstract::plain_nary_fun_< 2, plain_plus_<T1, T2> > - { - typedef plain_plus_<T1, T2> self; - xtd_res(self) impl_op(const T1& arg1, const T2& arg2) const + + + +namespace xtd { - return arg1 + arg2; - } - }; - typedef m2fun_<plain_plus_> plus_type; - const plus_type plus; + // logic + xtd_internal_decl_plain_binary_fun_op( land, and ); + xtd_internal_decl_plain_binary_fun_op( lor, or ); + xtd_internal_decl_plain_binary_fun_op( lxor, xor ); + xtd_internal_decl_plain_unary_fun_op( lnot, not ); - /*! \class xtd::plain_mult_<T> - ** - ** FIXME: doc - */ - template <typename T1, typename T2> struct plain_mult_; // fwd decl + // cmp - template <typename T1, typename T2> - struct fun_traits_< plain_mult_<T1, T2> > - { - typedef T1 arg1_type; - typedef T2 arg2_type; - typedef xtd_mult(T1, T2) res_type; - }; + xtd_internal_decl_plain_binary_fun_op( eq, == ); + xtd_internal_decl_plain_binary_fun_op( neq, != ); + xtd_internal_decl_plain_binary_fun_op( less, < ); + xtd_internal_decl_plain_binary_fun_op( leq, <= ); + xtd_internal_decl_plain_binary_fun_op( greater, > ); + xtd_internal_decl_plain_binary_fun_op( geq, >= ); - template <typename T1, typename T2> - struct plain_mult_ : public abstract::plain_nary_fun_< 2, plain_mult_<T1, T2> > - { - typedef plain_mult_<T1, T2> self; - xtd_res(self) impl_op(const T1& arg1, const T2& arg2) const - { - return arg1 * arg2; - } - }; - typedef m2fun_<plain_mult_> mult_type; - const mult_type mult; + // arith + + xtd_internal_decl_plain_binary_fun_op( plus, + ); + xtd_internal_decl_plain_binary_fun_op( minus, - ); + xtd_internal_decl_plain_binary_fun_op( mult, * ); + xtd_internal_decl_plain_binary_fun_op( div, / ); + xtd_internal_decl_plain_binary_fun_op( mod, % ); + + xtd_internal_decl_plain_unary_fun_op( uminus, - ); } // end of namespace xtd Index: xtd/literal.hh --- xtd/literal.hh (revision 442) +++ xtd/literal.hh (working copy) @@ -59,7 +59,12 @@ }; template <typename T> - struct plain_literal_ : public abstract::plain_nary_fun_< 0, plain_literal_<T> > + struct plain_literal_ + + : private mlc::assert_< mlc_is_not_a(T, abstract::fun_), + xtd::ERROR::FIXME >, + + public abstract::plain_nary_fun_< 0, plain_literal_<T> > { const T value; @@ -92,7 +97,12 @@ */ template <typename T> - struct meta_literal_ : public abstract::meta_nary_fun_< 0, meta_literal_<T> > + struct meta_literal_ + + : private mlc::assert_< mlc_is_not_a(T, abstract::fun_), + xtd::ERROR::FIXME >, + + public abstract::meta_nary_fun_< 0, meta_literal_<T> > { const T value; Index: xtd/ops_expr.hh --- xtd/ops_expr.hh (revision 442) +++ xtd/ops_expr.hh (working copy) @@ -33,48 +33,93 @@ # include <xtd/math/arith.hh> -namespace xtd -{ -// namespace abstract + +// FIXME: doc + + + +# define xtd_internal_decl_unary_operator(OperatorName, OperatorSymbol) \ + \ + template <typename Expr> \ + xtd::m1expr_<xtd::OperatorName##_type, Expr> \ + operator OperatorSymbol (const xtd::abstract::fun_expr_<Expr>& expr) \ + { \ + xtd::m1expr_<xtd::OperatorName##_type, Expr> tmp(expr); \ + return tmp; \ + } \ + \ + struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n + + +// FIXME: add something like: + +// template <typename Expr> +// struct OperatorName##_trait_ < Expr > // { +// typedef xtd::m1expr_<xtd::OperatorName##_type, Expr> ret; +// }; - // + - template <typename L, typename R> - xtd::m2expr_<xtd::plus_type, L, R> - operator + (const xtd::abstract::fun_expr_<L>& lexpr, - const xtd::abstract::fun_expr_<R>& rexpr) - { - xtd::m2expr_<xtd::plus_type, L, R> tmp(lexpr, rexpr); - return tmp; - } - - // HERE - -// template <typename R> -// xtd::m2expr_<xtd::plus_type, m0expr<literal_<int> >, R> -// operator + (int i, -// const xtd::abstract::fun_expr_<R>& rexpr) + +# define xtd_internal_decl_binary_operator(OperatorName, OperatorSymbol) \ + \ + template <typename Lexpr, typename Rexpr> \ + xtd::m2expr_<xtd::OperatorName##_type, Lexpr, Rexpr> \ + operator OperatorSymbol (const xtd::abstract::fun_expr_<Lexpr>& lexpr, \ + const xtd::abstract::fun_expr_<Rexpr>& rexpr) \ + { \ + xtd::m2expr_<xtd::OperatorName##_type, Lexpr, Rexpr> tmp(lexpr, rexpr); \ + return tmp; \ + } \ + \ + struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n + + +// FIXME: add something like: + +// template <typename Lexpr, typename Rexpr> +// struct OperatorName##_trait_ < Lexpr, Rexpr > // { -// xtd::m2expr<xtd::plus_type, L, R> tmp; -// return tmp; -// } +// typedef xtd::m2expr_<xtd::OperatorName##_type, Lexpr, Rexpr> ret; +// }; + - // * - template <typename L, typename R> - xtd::m2expr_<xtd::mult_type, L, R> - operator * (const xtd::abstract::fun_expr_<L>& lexpr, - const xtd::abstract::fun_expr_<R>& rexpr) + +namespace xtd { - xtd::m2expr_<xtd::mult_type, L, R> tmp(lexpr, rexpr); - return tmp; - } -// } // end of namespace xtd::abstract + // logic + + xtd_internal_decl_binary_operator( land, and ); + xtd_internal_decl_binary_operator( lor, or ); + xtd_internal_decl_binary_operator( lxor, xor ); + + xtd_internal_decl_unary_operator( lnot, not ); + + + // cmp + + xtd_internal_decl_binary_operator( eq, == ); + xtd_internal_decl_binary_operator( neq, != ); + xtd_internal_decl_binary_operator( less, < ); + xtd_internal_decl_binary_operator( leq, <= ); + xtd_internal_decl_binary_operator( greater, > ); + xtd_internal_decl_binary_operator( geq, >= ); + + + // arith + + xtd_internal_decl_binary_operator( plus, + ); + xtd_internal_decl_binary_operator( minus, - ); + xtd_internal_decl_binary_operator( mult, * ); + xtd_internal_decl_binary_operator( div, / ); + xtd_internal_decl_binary_operator( mod, % ); + + xtd_internal_decl_unary_operator( uminus, - ); } // end of namespace xtd Index: xtd/abstract/nary_fun.hh --- xtd/abstract/nary_fun.hh (revision 442) +++ xtd/abstract/nary_fun.hh (working copy) @@ -37,9 +37,15 @@ // FIXME: doc! - template <unsigned n> + template <unsigned n_> class nary_fun_ { + public: + + enum { nargs = n_ }; + + unsigned n() const { return n_; } + protected: nary_fun_() {} Index: xtd/abstract/fun_expr.hh --- xtd/abstract/fun_expr.hh (revision 442) +++ xtd/abstract/fun_expr.hh (working copy) @@ -74,11 +74,6 @@ return this->exact().impl_eval(arglist); } - unsigned nargs() const - { - return xtd_nargs(E); - } - protected: fun_expr_() {} }; Index: xtd/traits.hh --- xtd/traits.hh (revision 442) +++ xtd/traits.hh (working copy) @@ -31,23 +31,136 @@ # include <mlc/flags.hh> + +// logic + +# define xtd_land(L, R) typename xtd::land_trait_<L, R>::ret +# define xtd_lor(L, R) typename xtd::lor_trait_<L, R>::ret +# define xtd_lxor(L, R) typename xtd::lxor_trait_<L, R>::ret + +# define xtd_lnot(T) typename xtd::lnot_trait_<T>::ret + + +// cmp + +# define xtd_eq(L, R) typename xtd::eq_trait_<L, R>::ret +# define xtd_neq(L, R) typename xtd::neq_trait_<L, R>::ret +# define xtd_less(L, R) typename xtd::less_trait_<L, R>::ret +# define xtd_leq(L, R) typename xtd::leq_trait_<L, R>::ret +# define xtd_greater(L, R) typename xtd::greater_trait_<L, R>::ret +# define xtd_geq(L, R) typename xtd::geq_trait_<L, R>::ret + + +// arith + # define xtd_plus(L, R) typename xtd::plus_trait_< L, R >::ret +# define xtd_minus(L, R) typename xtd::minus_trait_<L, R>::ret # define xtd_mult(L, R) typename xtd::mult_trait_< L, R >::ret +# define xtd_div(L, R) typename xtd::div_trait_<L, R>::ret +# define xtd_mod(L, R) typename xtd::mod_trait_<L, R>::ret + +# define xtd_uminus(T) typename xtd::uminus_trait_<T>::ret + + + +// FIXME: xtd_plus(L, R) should be xtd::INTERNAL::plus_trait_< L, R >::ret +// FIXME: which checks that the trait *is* defined + namespace xtd { + // logic + + template <typename L, typename R> + struct land_trait_ : public mlc::undefined + { + }; + + template <typename L, typename R> + struct lor_trait_ : public mlc::undefined + { + }; + + template <typename L, typename R> + struct lxor_trait_ : public mlc::undefined + { + }; + + template <typename T> + struct lnot_trait_ : public mlc::undefined + { + }; + + + // cmp + + template <typename L, typename R> + struct eq_trait_ : public mlc::undefined + { + }; + + template <typename L, typename R> + struct neq_trait_ : public mlc::undefined + { + }; + + template <typename L, typename R> + struct less_trait_ : public mlc::undefined + { + }; + + template <typename L, typename R> + struct leq_trait_ : public mlc::undefined + { + }; + + template <typename L, typename R> + struct greater_trait_ : public mlc::undefined + { + }; + + template <typename L, typename R> + struct geq_trait_ : public mlc::undefined + { + }; + + + // arith + template <typename L, typename R> struct plus_trait_ : public mlc::undefined { }; template <typename L, typename R> - struct mult_trait_ : public mlc::undefined + struct minus_trait_ : public mlc::undefined + { + }; + + template <typename L, typename R> + struct mult_trait_ : public mlc::undefined // FIXME: or "times"? + { + }; + + template <typename L, typename R> + struct div_trait_ : public mlc::undefined { }; + template <typename L, typename R> + struct mod_trait_ : public mlc::undefined + { + }; + + template <typename T> + struct uminus_trait_ : public mlc::undefined + { + }; + + + } // end of namespace xtd Index: xtd/builtin/traits.hh --- xtd/builtin/traits.hh (revision 442) +++ xtd/builtin/traits.hh (working copy) @@ -31,56 +31,92 @@ # include <xtd/traits.hh> -namespace xtd -{ // FIXME: this is dummy and incomplete code! - // plus +# define xtd_internal_DUMMY_builtin_arith_traits(OperatorName) \ + \ + template <typename T> \ + struct OperatorName##_trait_ < T, T > \ + { \ + typedef T ret; \ + }; \ + \ + template <> struct OperatorName##_trait_ < float, int > { typedef float ret; }; \ + template <> struct OperatorName##_trait_ < int, float > { typedef float ret; }; \ + template <> struct OperatorName##_trait_ < double, int > { typedef double ret; }; \ + template <> struct OperatorName##_trait_ < int, double > { typedef double ret; }; \ + template <> struct OperatorName##_trait_ < double, float > { typedef double ret; }; \ + template <> struct OperatorName##_trait_ < float, double > { typedef double ret; }; \ + \ + template <> struct OperatorName##_trait_ < long double, int > { typedef long double ret; }; \ + template <> struct OperatorName##_trait_ < int, long double > { typedef long double ret; }; \ + template <> struct OperatorName##_trait_ < long double, float > { typedef long double ret; }; \ + template <> struct OperatorName##_trait_ < float, long double > { typedef long double ret; }; \ + template <> struct OperatorName##_trait_ < long double, double > { typedef long double ret; }; \ + template <> struct OperatorName##_trait_ < double, long double > { typedef long double ret; }; \ + \ + struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n + + +# define xtd_internal_DUMMY_builtin_logic_traits(OperatorName) \ + \ + template <> \ + struct OperatorName##_trait_ < bool, bool > \ + { \ + typedef bool ret; \ + }; \ + \ + struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n + + +# define xtd_internal_DUMMY_builtin_cmp_traits(OperatorName) \ + \ + template <typename T> \ + struct OperatorName##_trait_ < T, T > \ + { \ + typedef bool ret; \ + }; \ + \ + struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n + - template <typename T> - struct plus_trait_ < T, T > + + +namespace xtd { - typedef T ret; - }; - template <> struct plus_trait_ < float, int > { typedef float ret; }; - template <> struct plus_trait_ < int, float > { typedef float ret; }; - template <> struct plus_trait_ < double, int > { typedef double ret; }; - template <> struct plus_trait_ < int, double > { typedef double ret; }; - template <> struct plus_trait_ < double, float > { typedef double ret; }; - template <> struct plus_trait_ < float, double > { typedef double ret; }; - - template <> struct plus_trait_ < long double, int > { typedef long double ret; }; - template <> struct plus_trait_ < int, long double > { typedef long double ret; }; - template <> struct plus_trait_ < long double, float > { typedef long double ret; }; - template <> struct plus_trait_ < float, long double > { typedef long double ret; }; - template <> struct plus_trait_ < long double, double > { typedef long double ret; }; - template <> struct plus_trait_ < double, long double > { typedef long double ret; }; + // logic + xtd_internal_DUMMY_builtin_logic_traits( land ); + xtd_internal_DUMMY_builtin_logic_traits( lor ); + xtd_internal_DUMMY_builtin_logic_traits( lxor ); - // mult + template <> struct lnot_trait_< bool > { typedef bool ret; }; - template <typename T> - struct mult_trait_ < T, T > - { - typedef T ret; - }; + // cmp + + xtd_internal_DUMMY_builtin_cmp_traits( eq ); + xtd_internal_DUMMY_builtin_cmp_traits( neq ); + xtd_internal_DUMMY_builtin_cmp_traits( less ); + xtd_internal_DUMMY_builtin_cmp_traits( leq ); + xtd_internal_DUMMY_builtin_cmp_traits( greater ); + xtd_internal_DUMMY_builtin_cmp_traits( geq ); + + + // arith + + xtd_internal_DUMMY_builtin_arith_traits( plus ); + xtd_internal_DUMMY_builtin_arith_traits( minus ); + xtd_internal_DUMMY_builtin_arith_traits( mult ); + xtd_internal_DUMMY_builtin_arith_traits( div ); + xtd_internal_DUMMY_builtin_arith_traits( mod ); - template <> struct mult_trait_ < float, int > { typedef float ret; }; - template <> struct mult_trait_ < int, float > { typedef float ret; }; - template <> struct mult_trait_ < double, int > { typedef double ret; }; - template <> struct mult_trait_ < int, double > { typedef double ret; }; - template <> struct mult_trait_ < double, float > { typedef double ret; }; - template <> struct mult_trait_ < float, double > { typedef double ret; }; - - template <> struct mult_trait_ < long double, int > { typedef long double ret; }; - template <> struct mult_trait_ < int, long double > { typedef long double ret; }; - template <> struct mult_trait_ < long double, float > { typedef long double ret; }; - template <> struct mult_trait_ < float, long double > { typedef long double ret; }; - template <> struct mult_trait_ < long double, double > { typedef long double ret; }; - template <> struct mult_trait_ < double, long double > { typedef long double ret; }; + template <> struct uminus_trait_< int > { typedef int ret; }; + template <> struct uminus_trait_< float > { typedef float ret; }; + template <> struct uminus_trait_< double > { typedef double ret; }; + template <> struct uminus_trait_< long double > { typedef long double ret; }; } // end of namespace xtd Index: tests/cfun.cc --- tests/cfun.cc (revision 0) +++ tests/cfun.cc (revision 0) @@ -0,0 +1,35 @@ + +#include <iostream> +#include <xtd/cfun.hh> +#include <xtd/arg.hh> + + +namespace my +{ + + float foo() + { + return 5.1f; + } + + float bar(int i) + { + return float(i) * 3.f; + } + +} + + + +int main() +{ + std::cout << xtd::mk_plain_fun(my::foo)() << std::endl; + + { + using xtd::mk_fun; + using xtd::_1; + + std::cout << mk_fun(my::bar)(_1)(17) << std::endl; + } + +} Index: tests/Makefile.am --- tests/Makefile.am (revision 442) +++ tests/Makefile.am (working copy) @@ -11,12 +11,14 @@ id \ bind \ cast \ + cfun \ cos \ lit id_SOURCES = id.cc bind_SOURCES = bind.cc cast_SOURCES = cast.cc +cfun_SOURCES = cfun.cc cos_SOURCES = cos.cc lit_SOURCES = lit.cc

1 0

442: Separate xtd function expressions from meta functions. .
by Thierry Geraud 25 Mar '06

25 Mar '06

https://svn.lrde.epita.fr/svn/oln/trunk/extended Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Separate xtd function expressions from meta functions. . The design has changed: now an nary_fun_expr is not a subclass of meta_nary_fun. Both fun_nary_expr and meta_nary_fun inherit from open_nary_fun, which contains the shared part of nary_fun_expr and meta_nary_fun. Precisely, it provides the operator() that accepts different input: values or function expressions. * xtd/res.hh: Update. * xtd/cast.hh: Update. * xtd/math/trigo.hh: Update. * xtd/math/arith.hh: Update. * xtd/math/id.hh: Update. * xtd/mexpr.hh: Update. * xtd/args.hh: Update. * xtd/literal.hh: Update. * xtd/ops_expr.hh: Update. * xtd/abstract/open_nary_fun.hh: New. * xtd/abstract/plain_nary_fun.hh: New. * xtd/abstract/fun_expr.hh: Update. * xtd/abstract/meta_nary_fun.hh: New. * xtd/abstract/fun.hh: Update. * xtd/abstract/open_fun.hh: New. * xtd/abstract/plain_fun.hh: Update. * xtd/abstract/meta_fun.hh: Update. * xtd/abstract/fun_nary_expr.hh: New. * xtd/mfun.hh: Update. * xtd/TODO: New. * xtd/arg.hh: Update. * xtd/case.hh: Remove. * xtd/bind.hh: New. * xtd/internal: New. * xtd/internal/mlc.hh: New. * tests/id.cc: Update. * tests/bind.cc: Update. * tests/lit.cc: Update. tests/bind.cc | 4 tests/id.cc | 1 tests/lit.cc | 1 xtd/TODO | 5 xtd/abstract/fun.hh | 25 +-- xtd/abstract/fun_expr.hh | 247 ----------------------------- xtd/abstract/fun_nary_expr.hh | 234 ++++++++++++++++++++++++++++ xtd/abstract/meta_fun.hh | 292 ----------------------------------- xtd/abstract/meta_nary_fun.hh | 143 +++++++++++++++++ xtd/abstract/open_fun.hh | 71 ++++++++ xtd/abstract/open_nary_fun.hh | 340 +++++++++++++++++++++++++++++++++++++++++ xtd/abstract/plain_fun.hh | 196 ----------------------- xtd/abstract/plain_nary_fun.hh | 266 ++++++++++++++++++++++++++++++++ xtd/arg.hh | 9 - xtd/args.hh | 57 ++++++ xtd/bind.hh | 105 ++++++++++++ xtd/cast.hh | 14 - xtd/internal/mlc.hh | 54 ++++++ xtd/literal.hh | 81 --------- xtd/math/arith.hh | 2 xtd/math/id.hh | 2 xtd/math/trigo.hh | 6 xtd/mexpr.hh | 115 ++++++------- xtd/mfun.hh | 6 xtd/ops_expr.hh | 2 xtd/res.hh | 48 ++--- 26 files changed, 1381 insertions(+), 945 deletions(-) Index: xtd/res.hh --- xtd/res.hh (revision 441) +++ xtd/res.hh (working copy) @@ -28,19 +28,12 @@ #ifndef EXTENDED_RES_HH # define EXTENDED_RES_HH -# include <mlc/flags.hh> -# include <mlc/bool.hh> // FIXME: should be assert.hh -# include <mlc/if.hh> -# include <mlc/is_a.hh> -# include <mlc/comma.hh> -# include <mlc/cmp.hh> -# include <mlc/ret.hh> +# include <xtd/internal/mlc.hh> -# include <xtd/abstract/nary_fun.hh> - -// forward declarations ............................... +/// Forward declarations. +/// \{ namespace xtd { @@ -49,32 +42,27 @@ { template <typename E> - class meta_fun_; + class open_fun_; - template <unsigned n, typename E> - class meta_nary_fun_; + template <typename E> + class meta_fun_; template <typename E> class fun_expr_; - } // end of namespace xtd::abstract + template <unsigned n> + class nary_fun_; - template <typename F, - typename Expr> - struct m1expr; + class args; - template <typename F, - typename Expr1, typename Expr2> - struct m2expr; + } // end of namespace xtd::abstract - template <typename F, - typename Expr1, typename Expr2, typename Expr3> - struct m3expr; + template <typename A1, typename A2, typename A3> + struct args_; } // end of namespace xtd - -// end of forward declarations ........................ +/// \} @@ -160,7 +148,7 @@ // FIXME: doc... - // for meta_fun that are *not* fun_expr + // for meta_fun // ------------------------------------ @@ -264,7 +252,7 @@ - // for meta_fun that *are* fun_expr + // for fun_expr // ------------------------------------ template <typename F, @@ -295,7 +283,11 @@ typename A1 = mlc::none, typename A2 = mlc::none, typename A3 = mlc::none> - struct get_res_ : public mlc::if_< mlc_is_a(F, xtd::abstract::fun_expr_), + struct get_res_ + + // FIXME: add assertion "F is an xtd::abstract::open_fun_" + + : public mlc::if_< mlc_is_a(F, xtd::abstract::fun_expr_), get_expr_res_<F, xtd::args_<A1, A2, A3> >, do_get_res_<F, A1, A2, A3> >::ret {}; Index: xtd/cast.hh --- xtd/cast.hh (revision 441) +++ xtd/cast.hh (working copy) @@ -28,10 +28,8 @@ #ifndef EXTENDED_CAST_HH # define EXTENDED_CAST_HH -# include <mlc/pair.hh> - -# include <xtd/abstract/plain_fun.hh> -# include <xtd/abstract/meta_fun.hh> +# include <xtd/abstract/plain_nary_fun.hh> +# include <xtd/abstract/meta_nary_fun.hh> # include <xtd/mexpr.hh> @@ -105,16 +103,16 @@ */ template <typename Dest, typename A> - typename xtd::case_< xtd::tag::meta_1ary_fun_operator, + typename xtd::case_< xtd::tag::fun_operator_1, mlc::pair_< meta_cast_<Dest>, A > >::ret::res cast_(const A& a) { - typedef typename xtd::case_< xtd::tag::meta_1ary_fun_operator, + typedef typename xtd::case_< xtd::tag::fun_operator_1, mlc::pair_< meta_cast_<Dest>, A> >::ret case_t; - static const meta_cast_<Dest> the_; - return case_t::impl(&the_, a); + static const meta_cast_<Dest> target; + return case_t::impl(target, a); } Index: xtd/math/trigo.hh --- xtd/math/trigo.hh (revision 441) +++ xtd/math/trigo.hh (working copy) @@ -30,11 +30,7 @@ # include <cmath> -# include <mlc/assert.hh> -# include <mlc/logic.hh> -# include <mlc/cmp.hh> - -# include <xtd/abstract/plain_fun.hh> +# include <xtd/abstract/plain_nary_fun.hh> # include <xtd/mfun.hh> Index: xtd/math/arith.hh --- xtd/math/arith.hh (revision 441) +++ xtd/math/arith.hh (working copy) @@ -29,7 +29,7 @@ # define EXTENDED_MATH_ARITH_HH # include <xtd/builtin/traits.hh> -# include <xtd/abstract/plain_fun.hh> +# include <xtd/abstract/plain_nary_fun.hh> # include <xtd/mfun.hh> Index: xtd/math/id.hh --- xtd/math/id.hh (revision 441) +++ xtd/math/id.hh (working copy) @@ -28,7 +28,7 @@ #ifndef EXTENDED_MATH_ID_HH # define EXTENDED_MATH_ID_HH -# include <xtd/abstract/plain_fun.hh> +# include <xtd/abstract/plain_nary_fun.hh> # include <xtd/mfun.hh> Index: xtd/mexpr.hh --- xtd/mexpr.hh (revision 441) +++ xtd/mexpr.hh (working copy) @@ -28,16 +28,8 @@ #ifndef EXTENDED_MEXPR_HH # define EXTENDED_MEXPR_HH -# include <mlc/case.hh> -# include <mlc/assert.hh> -# include <mlc/logic.hh> -# include <mlc/is_a.hh> - -# include <xtd/abstract/nary_fun.hh> -# include <xtd/abstract/fun_expr.hh> -# include <xtd/args.hh> -# include <xtd/res.hh> -# include <xtd/literal.hh> +# include <xtd/abstract/meta_nary_fun.hh> +# include <xtd/abstract/fun_nary_expr.hh> @@ -57,6 +49,9 @@ struct MIXED_ARGUMENTS_IN_CALLING_A_TERNARY_META_FUNCTION__EXPR3; struct FIXME; + struct FIXME1; + struct FIXME2; + struct FIXME3; } // end of namespace xtd::ERROR @@ -98,10 +93,10 @@ : private mlc::assert_< mlc_is_a(F, abstract::nary_fun_<0>), ERROR::FIXME >, - private mlc::assert_< mlc_is_a(F, abstract::meta_fun_), - ERROR::FIXME >, + private mlc::assert_< mlc_is_a(F, abstract::open_fun_), + ERROR::FIXME2 >, - public abstract::nary_fun_expr_< 0, m0expr_<F> > + public abstract::fun_nary_expr_< 0, m0expr_<F> > { const F f; @@ -109,11 +104,9 @@ f() {} - m0expr_(const F& f) : - f(f) + m0expr_(const abstract::open_nary_fun_<0, F>& f) : + f(f.exact_()) { - mlc::assert_< mlc_is_a(F, abstract::nary_fun_<0>), - ERROR::FIXME >::check(); } template <typename Args> @@ -162,13 +155,13 @@ : private mlc::assert_< mlc_is_a(F, abstract::nary_fun_<1>), ERROR::FIXME >, - private mlc::assert_< mlc_is_a(F, abstract::meta_fun_), - ERROR::FIXME >, + private mlc::assert_< mlc_is_a(F, abstract::open_fun_), + ERROR::FIXME2 >, private mlc::assert_< mlc_is_a(Expr, abstract::fun_expr_), xtd::ERROR::FIXME >, - public abstract::nary_fun_expr_< xtd_nargs(Expr), + public abstract::fun_nary_expr_< xtd_nargs(Expr), m1expr_<F, Expr> > { typedef m1expr_<F, Expr> self; @@ -183,16 +176,14 @@ m1expr_(const abstract::fun_expr_<Expr>& expr) : f(), - expr(exact_of(expr)) + expr(expr.exact()) {} - m1expr_(const F& f, // FIXME: constraint? + m1expr_(const abstract::open_nary_fun_<1, F>& f, const abstract::fun_expr_<Expr>& expr) : - f(f), - expr(exact_of(expr)) + f(f.exact_()), + expr(expr.exact()) { - mlc::assert_< mlc_is_a(F, abstract::nary_fun_<1>), - ERROR::FIXME >::check(); } template <typename Args> @@ -244,16 +235,16 @@ struct m2expr_ : private mlc::assert_< mlc_is_a(F, abstract::nary_fun_<2>), - ERROR::FIXME >, + ERROR::FIXME1 >, - private mlc::assert_< mlc_is_a(F, abstract::meta_fun_), - ERROR::FIXME >, + private mlc::assert_< mlc_is_a(F, abstract::open_fun_), + ERROR::FIXME2 >, private mlc::assert_< mlc::and_< mlc_is_a(Expr1, abstract::fun_expr_), mlc_is_a(Expr2, abstract::fun_expr_) >, - xtd::ERROR::FIXME >, + xtd::ERROR::FIXME3 >, - public abstract::nary_fun_expr_< xtd_nargs(mlc_comma_2(m2expr_<F, Expr1, Expr2>)), + public abstract::fun_nary_expr_< xtd_nargs(mlc_comma_2(m2expr_<F, Expr1, Expr2>)), m2expr_<F, Expr1, Expr2> > { typedef m2expr_<F, Expr1, Expr2> self; @@ -271,19 +262,17 @@ m2expr_(const abstract::fun_expr_<Expr1>& expr1, const abstract::fun_expr_<Expr2>& expr2) : f(), - expr1(exact_of(expr1)), - expr2(exact_of(expr2)) + expr1(expr1.exact()), + expr2(expr2.exact()) {} - m2expr_(const F& f, + m2expr_(const abstract::open_nary_fun_<2, F>& f, const abstract::fun_expr_<Expr1>& expr1, const abstract::fun_expr_<Expr2>& expr2) : - f(f), - expr1(exact_of(expr1)), - expr2(exact_of(expr2)) + f(f.exact_()), + expr1(expr1.exact()), + expr2(expr2.exact()) { - mlc::assert_< mlc_is_a(F, abstract::nary_fun_<2>), - ERROR::FIXME >::check(); } template <typename Args> @@ -338,15 +327,15 @@ : private mlc::assert_< mlc_is_a(F, abstract::nary_fun_<3>), ERROR::FIXME >, - private mlc::assert_< mlc_is_a(F, abstract::meta_fun_), - ERROR::FIXME >, + private mlc::assert_< mlc_is_a(F, abstract::open_fun_), + ERROR::FIXME2 >, private mlc::assert_< mlc::and_list_< mlc_is_a(Expr1, abstract::fun_expr_), mlc_is_a(Expr2, abstract::fun_expr_), mlc_is_a(Expr3, abstract::fun_expr_) >, xtd::ERROR::FIXME >, - public abstract::nary_fun_expr_< xtd_nargs(mlc_comma_3(m3expr_<F, Expr1, Expr2, Expr3>)), + public abstract::fun_nary_expr_< xtd_nargs(mlc_comma_3(m3expr_<F, Expr1, Expr2, Expr3>)), m3expr_<F, Expr1, Expr2, Expr3> > { typedef m3expr_<F, Expr1, Expr2, Expr3> self; @@ -367,22 +356,20 @@ const abstract::fun_expr_<Expr2>& expr2, const abstract::fun_expr_<Expr3>& expr3) : f(), - expr1(exact_of(expr1)), - expr2(exact_of(expr2)), - expr3(exact_of(expr3)) + expr1(expr1.exact()), + expr2(expr2.exact()), + expr3(expr3.exact()) {} - m3expr_(const F& f, + m3expr_(const abstract::open_nary_fun_<3, F>& f, const abstract::fun_expr_<Expr1>& expr1, const abstract::fun_expr_<Expr2>& expr2, const abstract::fun_expr_<Expr3>& expr3) : - f(f), - expr1(exact_of(expr1)), - expr2(exact_of(expr2)), - expr3(exact_of(expr3)) + f(f.exact_()), + expr1(expr1.exact()), + expr2(expr2.exact()), + expr3(expr3.exact()) { - mlc::assert_< mlc_is_a(F, abstract::nary_fun_<3>), - ERROR::FIXME >::check(); } template <typename Args> @@ -396,32 +383,32 @@ - // meta_nary_fun_<1, F>::operator()(abstract::fun_expr_<Expr>& expr) const + // open_nary_fun_<1, F>::operator()(abstract::fun_expr_<Expr>& expr) const template <typename F, typename Expr> - struct case_< tag::meta_1ary_fun_operator, + struct case_< tag::fun_operator_1, mlc::pair_<F, Expr>, 1 > : public mlc::where_< mlc_is_a(Expr, abstract::fun_expr_) > { typedef m1expr_<F, Expr> res; - static res impl(const abstract::meta_nary_fun_<1, F>* this_, + static res impl(const abstract::open_nary_fun_<1, F>& target, const abstract::fun_expr_<Expr>& expr) { - res tmp(exact_of(*this_), expr); + res tmp(target, expr); return tmp; } }; - // meta_nary_fun_<2, F>::operator()(const fun_expr_<Expr1>& expr1, + // open_nary_fun_<2, F>::operator()(const fun_expr_<Expr1>& expr1, // const fun_expr_<Expr2>& expr2) const template <typename F, typename Expr1, typename Expr2> - struct case_< tag::meta_2ary_fun_operator, + struct case_< tag::fun_operator_2, mlc::valist_<F, Expr1, Expr2>, 1 > : public mlc::where_< mlc::or_< mlc_is_a(Expr1, abstract::fun_expr_), @@ -437,11 +424,11 @@ { typedef m2expr_<F, Expr1, Expr2> res; - static res impl(const abstract::meta_nary_fun_<2, F>* this_, + static res impl(const abstract::open_nary_fun_<2, F>& target, const abstract::fun_expr_<Expr1>& expr1, const abstract::fun_expr_<Expr2>& expr2) { - res tmp(exact_of(*this_), expr1, expr2); + res tmp(target, expr1, expr2); return tmp; } @@ -449,12 +436,12 @@ - // meta_nary_fun_<3, F>::operator()(const fun_expr_<Expr1>& expr1, + // open_nary_fun_<3, F>::operator()(const fun_expr_<Expr1>& expr1, // const fun_expr_<Expr2>& expr2, // const fun_expr_<Expr3>& expr3) const template <typename F, typename Expr1, typename Expr2, typename Expr3> - struct case_< tag::meta_3ary_fun_operator, + struct case_< tag::fun_operator_3, mlc::valist_<F, Expr1, Expr2, Expr3>, 1 > : public mlc::where_< mlc::or_list_< mlc_is_a(Expr1, abstract::fun_expr_), @@ -481,12 +468,12 @@ { typedef m3expr_<F, Expr1, Expr2, Expr3> res; - static res impl(const abstract::meta_nary_fun_<3, F>* this_, + static res impl(const abstract::open_nary_fun_<3, F>& target, const abstract::fun_expr_<Expr1>& expr1, const abstract::fun_expr_<Expr2>& expr2, const abstract::fun_expr_<Expr3>& expr3) { - res tmp(exact_of(*this_), expr1, expr2, expr3); + res tmp(target, expr1, expr2, expr3); return tmp; } }; Index: xtd/args.hh --- xtd/args.hh (revision 441) +++ xtd/args.hh (working copy) @@ -28,9 +28,13 @@ #ifndef EXTENDED_ARGS_HH # define EXTENDED_ARGS_HH -# include <mlc/flags.hh> -# include <mlc/assert.hh> -# include <mlc/is_a.hh> +# include <xtd/internal/mlc.hh> + + + +// FIXME: doc + +# define xtd_nargs(F) xtd::internal::get_nargs_<F>::ret @@ -60,6 +64,7 @@ + /*! \class xtd::args_<A1, ..> ** ** FIXME: to pack arguments @@ -158,6 +163,52 @@ } + + + + + namespace ERROR + { + + struct SPECIALIZATION_OF_xtd_nargs_IS_FOR_xtd_fun_expr_ONLY; + struct SPECIALIZATION_OF_xtd_nargs_NOT_FOUND_FOR_AN_xtd_fun_expr; + + } // end of namespace xtd::ERROR + + + + /*! \class xtd::nargs_<F> + ** + ** FIXME: doc + */ + + template <typename F> + struct nargs_ : public mlc::undefined + { + }; + + + namespace internal + { + + template <typename F> + struct get_nargs_ + + : // private mlc::assert_< mlc_is_a(F, xtd::abstract::fun_expr_), + // xtd::ERROR::SPECIALIZATION_OF_xtd_nargs_IS_FOR_xtd_fun_expr_ONLY >, + // FIXME: the static assertion above does *not* compile... + + private mlc::assert_< mlc_is_not_a(xtd::nargs_<F>, mlc::undefined), + xtd::ERROR::SPECIALIZATION_OF_xtd_nargs_NOT_FOUND_FOR_AN_xtd_fun_expr > + { + static const unsigned ret = xtd::nargs_<F>::ret; + }; + + } // end of xtd::internal + + + + } // end of namespace xtd Index: xtd/literal.hh --- xtd/literal.hh (revision 441) +++ xtd/literal.hh (working copy) @@ -28,12 +28,9 @@ #ifndef EXTENDED_LITERAL_HH # define EXTENDED_LITERAL_HH -# include <mlc/assert.hh> -# include <mlc/is_a.hh> - -# include <xtd/abstract/plain_fun.hh> -# include <xtd/abstract/meta_fun.hh> -# include <xtd/abstract/fun_expr.hh> +# include <xtd/abstract/plain_nary_fun.hh> +# include <xtd/abstract/meta_nary_fun.hh> +# include <xtd/abstract/fun_nary_expr.hh> @@ -139,7 +136,7 @@ : private mlc::assert_< mlc_is_not_a(T, abstract::fun_), xtd::ERROR::FIXME >, - public abstract::nary_fun_expr_< 0, literal_expr_<T> > + public abstract::fun_nary_expr_< 0, literal_expr_<T> > { const T value; @@ -168,75 +165,5 @@ } // end of namespace xtd -# include <xtd/mexpr.hh> -# include <xtd/arg.hh> - - -namespace xtd -{ - - namespace abstract - { - - // nary_fun_expr_< 2, E >::bind_i - - template <typename E> - template <typename T> - m2expr_< E, literal_expr_<T>, arg_<2> > - nary_fun_expr_< 2, E >::bind_1(const T& value) const - { - typedef m2expr_< E, literal_expr_<T>, arg_<2> > ret; - ret tmp(exact_of(this), lit(value), arg_<2>()); - return tmp; - } - - template <typename E> - template <typename T> - m2expr_< E, arg_<1>, literal_expr_<T> > - nary_fun_expr_< 2, E >::bind_2(const T& value) const - { - typedef m2expr_< E, arg_<1>, literal_expr_<T> > ret; - ret tmp(exact_of(this), arg_<1>(), lit(value)); - return tmp; - } - - - // nary_fun_expr_< 3, E >::bind_i - - template <typename E> - template <typename T> - m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > - nary_fun_expr_< 3, E >::bind_1(const T& value) const - { - typedef m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > ret; - ret tmp(exact_of(this), lit(value), arg_<2>(), arg_<3>()); - return tmp; - } - - template <typename E> - template <typename T> - m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > - nary_fun_expr_< 3, E >::bind_2(const T& value) const - { - typedef m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > ret; - ret tmp(exact_of(this), arg_<1>(), lit(value), arg_<3>()); - return tmp; - } - - template <typename E> - template <typename T> - m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > - nary_fun_expr_< 3, E >::bind_3(const T& value) const - { - typedef m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > ret; - ret tmp(exact_of(this), arg_<1>(), arg_<2>(), lit(value)); - return tmp; - } - - } // end of namespace xtd::abstract - -} // end of namespace xtd - - #endif // ! EXTENDED_LITERAL_HH Index: xtd/ops_expr.hh --- xtd/ops_expr.hh (revision 441) +++ xtd/ops_expr.hh (working copy) @@ -28,8 +28,6 @@ #ifndef EXTENDED_OPS_EXPR_HH # define EXTENDED_OPS_EXPR_HH -# include <mlc/case.hh> - # include <xtd/abstract/fun_expr.hh> # include <xtd/mexpr.hh> # include <xtd/math/arith.hh> Index: xtd/abstract/open_nary_fun.hh --- xtd/abstract/open_nary_fun.hh (revision 0) +++ xtd/abstract/open_nary_fun.hh (revision 0) @@ -0,0 +1,340 @@ +// Copyright (C) 2002, 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 +// 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 EXTENDED_ABSTRACT_OPEN_NARY_FUN_HH +# define EXTENDED_ABSTRACT_OPEN_NARY_FUN_HH + +# include <xtd/abstract/open_fun.hh> +# include <xtd/abstract/nary_fun.hh> +# include <xtd/res.hh> + + + + +// macros + +namespace xtd +{ + + + namespace ERROR + { + struct ARG_SHOULD_NOT_BE_A_PLAIN_FUN; + struct ARG1_SHOULD_NOT_BE_A_PLAIN_FUN; + struct ARG2_SHOULD_NOT_BE_A_PLAIN_FUN; + struct ARG3_SHOULD_NOT_BE_A_PLAIN_FUN; + + struct ARG_SHOULD_NOT_BE_A_META_FUN; + struct ARG1_SHOULD_NOT_BE_A_META_FUN; + struct ARG2_SHOULD_NOT_BE_A_META_FUN; + struct ARG3_SHOULD_NOT_BE_A_META_FUN; + + }// end of namespace xtd + + + + // FIXME: document case stuff... + + namespace tag + { + + struct fun_operator_1; + struct fun_operator_2; + struct fun_operator_3; + + } // end of namespace xtd::tag + + + // open_nary_fun_<1, E>::operator()(const A& a) const + + template <typename E, typename A> + struct default_case_ < tag::fun_operator_1, + mlc::pair_<E, A> > + { + typedef xtd_res_1(E, A) res; + + static res impl(const E& target, + const A& a) + { + return target.impl_calc(a); + } + }; + + + // open_nary_fun_<2, E>::operator()(const A1& a1, const A2& a2) const + + template <typename E, typename A1, typename A2> + struct default_case_ < tag::fun_operator_2, + mlc::valist_<E, A1, A2> > + { + typedef xtd_res_2(E, A1, A2) res; + + static res impl(const E& target, + const A1& a1, const A2& a2) + { + return target.impl_calc(a1, a2); + } + }; + + + // open_nary_fun_<3, E>::operator()(const A1& a1, const A2& a2, const A3& a3) const + + template <typename E, typename A1, typename A2, typename A3> + struct default_case_ < tag::fun_operator_3, + mlc::valist_<E, A1, A2, A3> > + { + typedef xtd_res_3(E, A1, A2, A3) res; + + static res impl(const E& target, + const A1& a1, const A2& a2, const A3& a3) + { + return target.impl_calc(a1, a2, a3); + } + }; + + +} // end of namespace xtd + + + + +namespace xtd +{ + + namespace abstract + { + + /// Forward declarations. + /// \{ + + template <typename E> class plain_fun_; + + template <typename E> class meta_fun_; + + /// \} + + + + /*! \class xtd::abstract::open_nary_fun_<n, E> + ** + ** FIXME: doc + ** + ** Parameter n is the number of arguments with n being 1, 2, or 3. + ** Parameter E is the exact type of the function. + */ + + template <unsigned n, typename E> + class open_nary_fun_; + + + + /*! \class xtd::abstract::open_nary_fun_<0, E> + ** + ** FIXME: doc + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class open_nary_fun_< 0, E > + + : public open_fun_<E>, + public nary_fun_<0> + { + public: + + /* + ** This member is not templated so its behavior at compile-time + ** is different than open_nary_fun_<n,E>::operator() where n > + ** 0. Here the return type should be known before the hierarchy + ** classes are fully compiled thus static assertions in the + ** macro xtd_res_0 do *not* work. An alternate macro is thus + ** in use. + */ + + xtd_internal_res_0(E) + operator()() const + { + return this->exact_().impl_calc(); + } + + protected: + open_nary_fun_() {} + }; + + + + /*! \class xtd::abstract::open_nary_fun_<1, E> + ** + ** FIXME: doc + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class open_nary_fun_< 1, E > + + : public open_fun_<E>, + public nary_fun_<1> + { + public: + + template <typename A> + struct case_ + + : private mlc::assert_< mlc_is_not_a(A, xtd::abstract::plain_fun_), + xtd::ERROR::ARG_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc_is_not_a(A, xtd::abstract::meta_fun_), + xtd::ERROR::ARG_SHOULD_NOT_BE_A_META_FUN >, + + public xtd::case_< xtd::tag::fun_operator_1, + mlc::pair_<E, A> >::ret + {}; + + template <typename A> + typename case_<A>::res + operator()(const A& a) const + { + return case_<A>::impl(this->exact_(), a); + } + + protected: + open_nary_fun_() {} + }; + + + + /*! \class xtd::abstract::operator_<2, E> + ** + ** Abstract base class for meta functions taking two arguments. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class open_nary_fun_< 2, E > + + : public open_fun_<E>, + public nary_fun_<2> + { + public: + + template <typename A1, typename A2> + struct case_ + + : private mlc::assert_< mlc_is_not_a(A1, xtd::abstract::plain_fun_), + xtd::ERROR::ARG1_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc_is_not_a(A1, xtd::abstract::meta_fun_), + xtd::ERROR::ARG1_SHOULD_NOT_BE_A_META_FUN >, + + private mlc::assert_< mlc_is_not_a(A2, xtd::abstract::plain_fun_), + xtd::ERROR::ARG2_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc_is_not_a(A2, xtd::abstract::meta_fun_), + xtd::ERROR::ARG2_SHOULD_NOT_BE_A_META_FUN >, + + public xtd::case_< xtd::tag::fun_operator_2, + mlc::valist_<E, A1, A2> >::ret + {}; + + template <typename A1, typename A2> + typename case_<A1, A2>::res + operator()(const A1& a1, const A2& a2) const + { + return case_<A1, A2>::impl(this->exact_(), a1, a2); + } + + protected: + open_nary_fun_() {} + }; + + + /*! \class xtd::abstract::open_nary_fun_<3, E> + ** + ** Abstract base class for meta functions taking three arguments. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class open_nary_fun_< 3, E > + + : public open_fun_<E>, + public nary_fun_<3> + { + public: + + template <typename A1, typename A2, typename A3> + struct case_ + + : private mlc::assert_< mlc_is_not_a(A1, xtd::abstract::plain_fun_), + xtd::ERROR::ARG1_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc_is_not_a(A1, xtd::abstract::meta_fun_), + xtd::ERROR::ARG1_SHOULD_NOT_BE_A_META_FUN >, + + private mlc::assert_< mlc_is_not_a(A2, xtd::abstract::plain_fun_), + xtd::ERROR::ARG2_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc_is_not_a(A2, xtd::abstract::meta_fun_), + xtd::ERROR::ARG2_SHOULD_NOT_BE_A_META_FUN >, + + private mlc::assert_< mlc_is_not_a(A3, xtd::abstract::plain_fun_), + xtd::ERROR::ARG3_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc_is_not_a(A3, xtd::abstract::meta_fun_), + xtd::ERROR::ARG3_SHOULD_NOT_BE_A_META_FUN >, + + public xtd::case_< xtd::tag::fun_operator_3, + mlc::valist_<E, A1, A2, A3> >::ret + {}; + + template <typename A1, typename A2, typename A3> + typename case_<A1, A2, A3>::res + operator()(const A1& a1, const A2& a2, const A3& a3) const + { + return case_<A1, A2, A3>::impl(this->exact_(), a1, a2, a3); + } + + protected: + open_nary_fun_() {} + }; + + + } // end of namespace xtd::abstract + +} // end of namespace xtd + + + +#endif // ! EXTENDED_ABSTRACT_OPEN_NARY_FUN_HH Index: xtd/abstract/plain_nary_fun.hh --- xtd/abstract/plain_nary_fun.hh (revision 0) +++ xtd/abstract/plain_nary_fun.hh (revision 0) @@ -0,0 +1,266 @@ +// Copyright (C) 2002, 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 +// 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 EXTENDED_ABSTRACT_PLAIN_NARY_FUN_HH +# define EXTENDED_ABSTRACT_PLAIN_NARY_FUN_HH + +# include <xtd/abstract/plain_fun.hh> +# include <xtd/abstract/nary_fun.hh> + + +// macros + +# define xtd_arg(F) typename xtd::typedef_::arg_type::from_<xtd::fun_traits_<F> >::ret +# define xtd_arg1(F) typename xtd::typedef_::arg1_type::from_<xtd::fun_traits_<F> >::ret +# define xtd_arg2(F) typename xtd::typedef_::arg2_type::from_<xtd::fun_traits_<F> >::ret +# define xtd_arg3(F) typename xtd::typedef_::arg3_type::from_<xtd::fun_traits_<F> >::ret + + + + +namespace xtd +{ + + namespace ERROR + { + struct xtd_fun_traits_SHOULD_DEFINE_arg_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_1; + + struct xtd_fun_traits_SHOULD_DEFINE_arg1_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_2; + struct xtd_fun_traits_SHOULD_DEFINE_arg2_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_2; + + struct xtd_fun_traits_SHOULD_DEFINE_arg1_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3; + struct xtd_fun_traits_SHOULD_DEFINE_arg2_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3; + struct xtd_fun_traits_SHOULD_DEFINE_arg3_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3; + + struct AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT; + + // FIXME: add error messages corresponding to definitions without sense + // FIXME: such as having arg2 when the plain function is unary + + } // end of namespace xtd::ERROR + + + + mlc_decl_typedef(arg_type); + mlc_decl_typedef(arg1_type); + mlc_decl_typedef(arg2_type); + mlc_decl_typedef(arg3_type); + + + namespace abstract + { + + /*! \class xtd::abstract::plain_nary_fun_<n, E> + ** + ** Abstract base class for plain functions with an explicit number + ** of arguments. + ** + ** Parameter n is the number of arguments with n being 0, 1, 2, or + ** 3. + ** + ** Parameter E is the exact type of the function. + */ + + template <unsigned n, typename E> + class plain_nary_fun_; + + + + /*! \class xtd::abstract::plain_nary_fun_<0, E> + ** + ** Abstract base class for plain functions taking no argument. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class plain_nary_fun_< 0, E > + + : public plain_fun_<E>, + public nary_fun_<0> + + // FIXME: add many assertions in this class and the following ones + // FIXME: for instance, eq_< xtd_arg(E), mlc::not_found >, etc. + { + public: + + xtd_res(E) operator()() const + { + return this->exact().impl_op(); + } + + protected: + plain_nary_fun_() {} + }; + + + + /*! \class xtd::abstract::plain_nary_fun_<1, E> + ** + ** Abstract base class for plain functions taking one argument. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class plain_nary_fun_< 1, E > + + : public plain_fun_<E>, + public nary_fun_<1>, + + private mlc::assert_< mlc::neq_<xtd_arg(E), mlc::not_found>, + xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_1 > + { + public: + + xtd_res(E) operator()(const xtd_arg(E)& arg) const + { + return this->exact().impl_op(arg); + } + + template <typename A> + xtd_res(E) operator()(const A& arg) const + { + mlc::assert_< mlc_is_not_a(A, abstract::fun_), + xtd::ERROR::AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT >::check(); + // FIXME: check that conversion is ok + return this->exact().impl_op(arg); + } + + protected: + plain_nary_fun_() {} + }; + + + + /*! \class xtd::abstract::plain_nary_fun_<2, E> + ** + ** Abstract base class for plain functions taking two arguments. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class plain_nary_fun_< 2, E > + + : public plain_fun_<E>, + public nary_fun_<2>, + + private mlc::assert_< mlc::neq_<xtd_arg1(E), mlc::not_found>, + xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg1_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_2 >, + + private mlc::assert_< mlc::neq_<xtd_arg2(E), mlc::not_found>, + xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg2_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_2 > + { + public: + + xtd_res(E) operator()(const xtd_arg1(E)& arg1, + const xtd_arg2(E)& arg2) const + { + return this->exact().impl_op(arg1, arg2); + } + + template <typename A1, typename A2> + xtd_res(E) operator()(const A1& arg1, const A2& arg2) const + { + // FIXME: be more specific in the assertions below (and also in the other classes) + mlc::assert_< mlc_is_not_a(A1, abstract::fun_), + xtd::ERROR::AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT >::check(); + mlc::assert_< mlc_is_not_a(A2, abstract::fun_), + xtd::ERROR::AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT >::check(); + // FIXME: check that conversions below are ok + return this->exact().impl_op(arg1, arg2); + } + + protected: + plain_nary_fun_() {} + }; + + + + /*! \class xtd::abstract::plain_nary_fun_<3, E> + ** + ** Abstract base class for plain functions taking three arguments. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class plain_nary_fun_< 3, E > + + : public plain_fun_<E>, + public nary_fun_<3>, + + private mlc::assert_< mlc::neq_<xtd_arg1(E), mlc::not_found>, + xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg1_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3 >, + + private mlc::assert_< mlc::neq_<xtd_arg2(E), mlc::not_found>, + xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg2_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3 >, + + private mlc::assert_< mlc::neq_<xtd_arg3(E), mlc::not_found>, + xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg3_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3 > + { + public: + + xtd_res(E) operator()(const xtd_arg1(E)& arg1, + const xtd_arg2(E)& arg2, + const xtd_arg3(E)& arg3) const + { + return this->exact().impl_op(arg1, arg2, arg3); + } + + template <typename A1, typename A2, typename A3> + xtd_res(E) operator()(const A1& arg1, + const A2& arg2, + const A3& arg3) const + { + mlc::assert_< mlc_is_not_a(A1, abstract::fun_), + xtd::ERROR::AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT >::check(); + mlc::assert_< mlc_is_not_a(A2, abstract::fun_), + xtd::ERROR::AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT >::check(); + mlc::assert_< mlc_is_not_a(A3, abstract::fun_), + xtd::ERROR::AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT >::check(); + // FIXME: check that conversions below are ok + return this->exact().impl_op(arg1, arg2, arg3); + } + + protected: + plain_nary_fun_() {} + }; + + + } // end of namespace xtd::abstract + +} // end of namespace xtd + + + +#endif // ! EXTENDED_ABSTRACT_PLAIN_NARY_FUN_HH Index: xtd/abstract/fun_expr.hh --- xtd/abstract/fun_expr.hh (revision 441) +++ xtd/abstract/fun_expr.hh (working copy) @@ -28,20 +28,9 @@ #ifndef EXTENDED_ABSTRACT_FUN_EXPR_HH # define EXTENDED_ABSTRACT_FUN_EXPR_HH -# include <mlc/flags.hh> -# include <mlc/bool.hh> -# include <mlc/is_a.hh> -# include <mlc/comma.hh> - -# include <xtd/args.hh> +# include <xtd/abstract/fun.hh> # include <xtd/res.hh> -# include <xtd/abstract/meta_fun.hh> - - - -// FIXME: doc - -# define xtd_nargs(F) xtd::internal::get_nargs_<F>::ret +# include <xtd/args.hh> @@ -53,267 +42,45 @@ { struct INTERNAL_ILL_FORMED_CALL_TO_xtd_fun_expr_eval; - struct SPECIALIZATION_OF_xtd_nargs_IS_FOR_xtd_fun_expr_ONLY; - struct SPECIALIZATION_OF_xtd_nargs_NOT_FOUND_FOR_AN_xtd_fun_expr; } // end of namespace xtd::ERROR - - /// Forward declarations. - /// \{ - namespace abstract { - template <typename E> class fun_expr_; - } - - template <typename F, typename Expr1, typename Expr2> - struct m2expr_; - - template <typename F, typename Expr1, typename Expr2, typename Expr3> - struct m3expr_; - - template <typename T> - struct literal_expr_; - - template <unsigned i> - struct arg_; - - /// \} - - - - /*! \class xtd::nargs_<F> - ** - ** FIXME: doc - ** FIXME: and add a mechanism so that the type of F is checked - ** FIXME: Cf. get_res0_ in xtd/abstract/meta_fun.hh - */ - - template <typename F> - struct nargs_ : public mlc::undefined - { - }; - - - namespace internal - { - - template <typename F> - struct get_nargs_ - - : // private mlc::assert_< mlc_is_a(F, xtd::abstract::fun_expr_), - // xtd::ERROR::SPECIALIZATION_OF_xtd_nargs_IS_FOR_xtd_fun_expr_ONLY >, - // FIXME: the static assertion above does *not* compile... - - private mlc::assert_< mlc_is_not_a(xtd::nargs_<F>, mlc::undefined), - xtd::ERROR::SPECIALIZATION_OF_xtd_nargs_NOT_FOUND_FOR_AN_xtd_fun_expr > - { - static const unsigned ret = xtd::nargs_<F>::ret; - }; - } // end of xtd::internal - - - - namespace abstract - { /*! \class xtd::abstract::fun_expr_<E> ** ** Abstract base class for function expressions. Parameter E is ** the exact type of the function expression. - ** - ** Design note: this class does not derive from xtd::abstract::any - ** to avoid diamond inheritance since fun_expr classes are also - ** meta_fun classes. */ template <typename E> class fun_expr_ - // FIXME: at that point, we should verify that nargs_<E> is user-defined... - : public fun_<E> { public: template <typename Args> xtd_expr_res(E, Args) - eval(const Args& as) const + eval(const Args& arglist) const { mlc::assert_< mlc_is_a(Args, xtd::abstract::args), xtd::ERROR::INTERNAL_ILL_FORMED_CALL_TO_xtd_fun_expr_eval >::check(); - return exact_of(this)->impl_eval(as); + return this->exact().impl_eval(arglist); } - protected: - fun_expr_() {} - }; - - - - - - - /*! \class xtd::abstract::nary_fun_expr_<n, E> - ** - ** Abstract base class for function expressions with an explicit - ** number of arguments. - ** - ** Parameter n is the number of arguments with n being 0, 1, 2, or - ** 3. - ** - ** Parameter E is the exact type of the function. - */ - - template <unsigned n, typename E> - class nary_fun_expr_; - - - - /*! \class xtd::abstract::nary_fun_expr_<0, E> - ** - ** Abstract base class for function expressions taking no - ** argument. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class nary_fun_expr_< 0, E > - - : public fun_expr_<E>, - public meta_nary_fun_<0, E> + unsigned nargs() const { - public: - - // the return type here is not xtd_res_0(E) - // the explanations are given with meta_nary_fun_<0, E>::operator()() - // in file xtd/abstract/meta_fun.hh - - xtd_internal_res_0(E) - impl_calc() const - { - return this->eval(mk_args()); - } - - // no bind_i method here - - protected: - nary_fun_expr_() {} - }; - - - - /*! \class xtd::abstract::nary_fun_expr_<1, E> - ** - ** Abstract base class for function expressions taking one - ** argument. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class nary_fun_expr_< 1, E > - - : public fun_expr_<E>, - public meta_nary_fun_<1, E> - { - public: - - template <typename A> - xtd_res_1(E, A) - impl_calc(const A& a) const - { - return this->eval(mk_args(a)); - } - - // no bind_i method here - - protected: - nary_fun_expr_() {} - }; - - - - /*! \class xtd::abstract::nary_fun_expr_<2, E> - ** - ** Abstract base class for function expressions taking two - ** arguments. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class nary_fun_expr_< 2, E > - - : public fun_expr_<E>, - public meta_nary_fun_<2, E> - { - public: - - template <typename A1, typename A2> - xtd_res_2(E, A1, A2) - impl_calc(const A1& a1, const A2& a2) const - { - return this->eval(mk_args(a1, a2)); - } - - template <typename T> - m2expr_< E, literal_expr_<T>, arg_<2> > - bind_1(const T& value) const; - - template <typename T> - m2expr_< E, arg_<1>, literal_expr_<T> > - bind_2(const T& value) const; - - protected: - nary_fun_expr_() {} - }; - - - - /*! \class xtd::abstract::nary_fun_expr_<3, E> - ** - ** Abstract base class for function expressions taking three - ** arguments. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class nary_fun_expr_< 3, E > - - : public fun_expr_<E>, - public meta_nary_fun_<3, E> - { - public: - - template <typename A1, typename A2, typename A3> - xtd_res_3(E, A1, A2, A3) - impl_calc(const A1& a1, const A2& a2, const A3& a3) const - { - return this->eval(mk_args(a1, a2, a3)); + return xtd_nargs(E); } - template <typename T> - m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > - bind_1(const T& value) const; - - template <typename T> - m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > - bind_2(const T& value) const; - - template <typename T> - m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > - bind_3(const T& value) const; - protected: - nary_fun_expr_() {} + fun_expr_() {} }; Index: xtd/abstract/meta_nary_fun.hh --- xtd/abstract/meta_nary_fun.hh (revision 0) +++ xtd/abstract/meta_nary_fun.hh (revision 0) @@ -0,0 +1,143 @@ +// Copyright (C) 2002, 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 +// 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 EXTENDED_ABSTRACT_META_NARY_FUN_HH +# define EXTENDED_ABSTRACT_META_NARY_FUN_HH + +# include <xtd/abstract/meta_fun.hh> +# include <xtd/abstract/open_nary_fun.hh> + + + +namespace xtd +{ + + namespace abstract + { + + + /*! \class xtd::abstract::meta_nary_fun_<n, E> + ** + ** Abstract base class for meta functions with an explicit number + ** of arguments. + ** + ** Parameter n is the number of arguments with n being 1, 2, or 3. + ** + ** Parameter E is the exact type of the function. + */ + + template <unsigned n, typename E> + class meta_nary_fun_; + + + + /*! \class xtd::abstract::meta_nary_fun_<0, E> + ** + ** Abstract base class for meta functions taking no argument. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class meta_nary_fun_< 0, E > + + : public meta_fun_<E>, + public open_nary_fun_<0, E> + { + protected: + meta_nary_fun_() {} + }; + + + + /*! \class xtd::abstract::meta_nary_fun_<1, E> + ** + ** Abstract base class for meta functions taking one argument. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class meta_nary_fun_< 1, E > + + : public meta_fun_<E>, + public open_nary_fun_<1, E> + { + protected: + meta_nary_fun_() {} + }; + + + + /*! \class xtd::abstract::meta_nary_fun_<2, E> + ** + ** Abstract base class for meta functions taking two arguments. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class meta_nary_fun_< 2, E > + + : public meta_fun_<E>, + public open_nary_fun_<2, E> + { + protected: + meta_nary_fun_() {} + }; + + + + /*! \class xtd::abstract::meta_nary_fun_<3, E> + ** + ** Abstract base class for meta functions taking three arguments. + ** This class is defined as a specialization. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class meta_nary_fun_< 3, E > + + : public meta_fun_<E>, + public open_nary_fun_<3, E> + { + protected: + meta_nary_fun_() {} + }; + + + } // end of namespace xtd::abstract + +} // end of namespace xtd + + + +#endif // ! EXTENDED_ABSTRACT_META_NARY_FUN_HH Index: xtd/abstract/fun.hh --- xtd/abstract/fun.hh (revision 441) +++ xtd/abstract/fun.hh (working copy) @@ -28,6 +28,8 @@ #ifndef EXTENDED_ABSTRACT_FUN_HH # define EXTENDED_ABSTRACT_FUN_HH +# include <xtd/internal/mlc.hh> + namespace xtd { @@ -44,6 +46,13 @@ template <typename E> class fun_ { + public: + + const E& exact() const + { + return *(const E*)(const void*)(this); + } + protected: fun_() {} }; @@ -52,22 +61,6 @@ } // end of namespace xtd::abstract - - // FIXME: doc - - template <typename E> - const E* exact_of(const abstract::fun_<E>* f) - { - return (const E*)(const void*)(f); - } - - template <typename E> - const E& exact_of(const abstract::fun_<E>& f) - { - return *(const E*)(const void*)(&f); - } - - } // end of namespace xtd Index: xtd/abstract/open_fun.hh --- xtd/abstract/open_fun.hh (revision 0) +++ xtd/abstract/open_fun.hh (revision 0) @@ -0,0 +1,71 @@ +// Copyright (C) 2002, 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 +// 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 EXTENDED_ABSTRACT_OPEN_FUN_HH +# define EXTENDED_ABSTRACT_OPEN_FUN_HH + +# include <xtd/internal/mlc.hh> + + +namespace xtd +{ + + namespace abstract + { + + /*! \class xtd::abstract::open_fun_<E> + ** + ** FIXME: doc + ** + ** Parameter n is the number of arguments with n being 1, 2, or 3. + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class open_fun_ + { + protected: + + open_fun_() + {} + + public: + + const E& exact_() const + { + return *(const E*)(const void*)(this); + } + }; + + + } // end of namespace xtd::abstract + +} // end of namespace xtd + + + +#endif // ! EXTENDED_ABSTRACT_OPEN_FUN_HH Index: xtd/abstract/plain_fun.hh --- xtd/abstract/plain_fun.hh (revision 441) +++ xtd/abstract/plain_fun.hh (working copy) @@ -28,24 +28,10 @@ #ifndef EXTENDED_ABSTRACT_PLAIN_FUN_HH # define EXTENDED_ABSTRACT_PLAIN_FUN_HH -# include <mlc/flags.hh> -# include <mlc/assert.hh> -# include <mlc/is_a.hh> -# include <mlc/typedef.hh> -# include <mlc/assert.hh> -# include <mlc/abort.hh> - # include <xtd/abstract/fun.hh> -# include <xtd/abstract/nary_fun.hh> - - -// macros -# define xtd_arg(F) typename xtd::typedef_::arg_type::from_<xtd::fun_traits_<F> >::ret -# define xtd_arg1(F) typename xtd::typedef_::arg1_type::from_<xtd::fun_traits_<F> >::ret -# define xtd_arg2(F) typename xtd::typedef_::arg2_type::from_<xtd::fun_traits_<F> >::ret -# define xtd_arg3(F) typename xtd::typedef_::arg3_type::from_<xtd::fun_traits_<F> >::ret +// macro # define xtd_res(F) typename xtd::typedef_::res_type::from_<xtd::fun_traits_<F> >::ret @@ -59,25 +45,8 @@ { struct SPECIALIZATION_OF_xtd_fun_traits_NOT_FOUND_FOR_AN_xtd_plain_fun; struct xtd_fun_traits_SHOULD_DEFINE_res_type_FOR_AN_xtd_plain_fun; - - struct xtd_fun_traits_SHOULD_DEFINE_arg_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_1; - - struct xtd_fun_traits_SHOULD_DEFINE_arg1_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_2; - struct xtd_fun_traits_SHOULD_DEFINE_arg2_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_2; - - struct xtd_fun_traits_SHOULD_DEFINE_arg1_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3; - struct xtd_fun_traits_SHOULD_DEFINE_arg2_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3; - struct xtd_fun_traits_SHOULD_DEFINE_arg3_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3; - struct YOU_SHOULD_NOT_DERIVE_FROM_xtd_plain_fun_BUT_FROM_xtd_plain_nary_fun; - struct FIXME; - - struct AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT; - - // FIXME: add error messages corresponding to definitions without sense - // FIXME: such as having arg2 when the plain function is unary - } // end of namespace xtd::ERROR @@ -85,31 +54,15 @@ template <typename F> struct fun_traits_ : public mlc::undefined { - // nothing }; - mlc_decl_typedef(arg_type); - - mlc_decl_typedef(arg1_type); - mlc_decl_typedef(arg2_type); - mlc_decl_typedef(arg3_type); - mlc_decl_typedef(res_type); namespace abstract { - /// Forward declarations. - /// \{ - template <unsigned n, typename E> class plain_nary_fun_; - template <typename E> class meta_fun_; - template <typename E> class fun_expr_; - /// \} - - - /*! \class xtd::abstract::plain_fun_ ** ** Abstract base class for plain functions. Parameter E is the @@ -137,153 +90,6 @@ }; - /*! \class xtd::abstract::plain_nary_fun_<n, E> - ** - ** Abstract base class for plain functions with an explicit number - ** of arguments. - ** - ** Parameter n is the number of arguments with n being 0, 1, 2, or - ** 3. - ** - ** Parameter E is the exact type of the function. - */ - - template <unsigned n, typename E> - class plain_nary_fun_; - - - - /*! \class xtd::abstract::plain_nary_fun_<0, E> - ** - ** Abstract base class for plain functions taking no argument. - ** This class is defined as a specialization. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class plain_nary_fun_< 0, E > - - : public plain_fun_<E>, - public nary_fun_<0> - { - public: - - xtd_res(E) operator()() const - { - return exact_of(this)->impl_op(); - } - - protected: - plain_nary_fun_() {} - }; - - - - /*! \class xtd::abstract::plain_nary_fun_<1, E> - ** - ** Abstract base class for plain functions taking one argument. - ** This class is defined as a specialization. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class plain_nary_fun_< 1, E > - - : public plain_fun_<E>, - public nary_fun_<1>, - - private mlc::assert_< mlc::neq_<xtd_arg(E), mlc::not_found>, - xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_1 > - { - public: - - template <typename F> - void operator()(const abstract::fun_<F>&) const - { - mlc::abort_< F, - xtd::ERROR::AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT >::check(); - } - - xtd_res(E) operator()(const xtd_arg(E)& arg) const - { - return exact_of(this)->impl_op(arg); - } - - protected: - plain_nary_fun_() {} - }; - - - - /*! \class xtd::abstract::plain_nary_fun_<2, E> - ** - ** Abstract base class for plain functions taking two arguments. - ** This class is defined as a specialization. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class plain_nary_fun_< 2, E > - - : public plain_fun_<E>, - public nary_fun_<2>, - - private mlc::assert_< mlc::neq_<xtd_arg1(E), mlc::not_found>, - xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg1_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_2 >, - - private mlc::assert_< mlc::neq_<xtd_arg2(E), mlc::not_found>, - xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg2_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_2 > - { - public: - xtd_res(E) operator()(const xtd_arg1(E)& arg1, - const xtd_arg2(E)& arg2) const - { - return exact_of(this)->impl_op(arg1, arg2); - } - protected: - plain_nary_fun_() {} - }; - - - - /*! \class xtd::abstract::plain_nary_fun_<3, E> - ** - ** Abstract base class for plain functions taking three arguments. - ** This class is defined as a specialization. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class plain_nary_fun_< 3, E > - - : public plain_fun_<E>, - public nary_fun_<3>, - - private mlc::assert_< mlc::neq_<xtd_arg1(E), mlc::not_found>, - xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg1_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3 >, - - private mlc::assert_< mlc::neq_<xtd_arg2(E), mlc::not_found>, - xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg2_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3 >, - - private mlc::assert_< mlc::neq_<xtd_arg3(E), mlc::not_found>, - xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg3_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_3 > - { - public: - xtd_res(E) operator()(const xtd_arg1(E)& arg1, - const xtd_arg2(E)& arg2, - const xtd_arg3(E)& arg3) const - { - return exact_of(this)->impl_op(arg1, arg2, arg3); - } - protected: - plain_nary_fun_() {} - }; - - } // end of namespace xtd::abstract } // end of namespace xtd Index: xtd/abstract/meta_fun.hh --- xtd/abstract/meta_fun.hh (revision 441) +++ xtd/abstract/meta_fun.hh (working copy) @@ -28,108 +28,20 @@ #ifndef EXTENDED_ABSTRACT_META_FUN_HH # define EXTENDED_ABSTRACT_META_FUN_HH -# include <mlc/flags.hh> -# include <mlc/pair.hh> -# include <mlc/valist.hh> - # include <xtd/abstract/fun.hh> -# include <xtd/abstract/nary_fun.hh> -# include <xtd/args.hh> -# include <xtd/res.hh> -# include <xtd/case.hh> - - -// macros - namespace xtd { namespace ERROR { - struct ARG_SHOULD_NOT_BE_A_PLAIN_FUN; - struct ARG1_SHOULD_NOT_BE_A_PLAIN_FUN; - struct ARG2_SHOULD_NOT_BE_A_PLAIN_FUN; - struct ARG3_SHOULD_NOT_BE_A_PLAIN_FUN; - - struct ARG_SHOULD_NOT_BE_A_META_NON_EXPR_FUN; - struct ARG1_SHOULD_NOT_BE_A_META_NON_EXPR_FUN; - struct ARG2_SHOULD_NOT_BE_A_META_NON_EXPR_FUN; - struct ARG3_SHOULD_NOT_BE_A_META_NON_EXPR_FUN; - - }// end of namespace xtd - - - - // FIXME: document case stuff... - - namespace tag - { - - struct meta_1ary_fun_operator; - struct meta_2ary_fun_operator; - struct meta_3ary_fun_operator; - - } // end of namespace xtd::tag - - - // meta_nary_fun_<1, E>::operator()(const A& a) const - - template <typename E, typename A> - struct default_case_ < tag::meta_1ary_fun_operator, - mlc::pair_<E, A> > - { - typedef xtd_res_1(E, A) res; + struct YOU_SHOULD_NOT_DERIVE_DIRECTLY_FROM_xtd_meta_fun_BUT_FROM_xtd_meta_nary_fun_; - static res impl(const abstract::meta_nary_fun_<1, E>* this_, - const A& a) - { - return exact_of(this_)->impl_calc(a); - } - }; + } // end of namespace xtd::ERROR - // meta_nary_fun_<2, E>::operator()(const A1& a1, const A2& a2) const - - template <typename E, typename A1, typename A2> - struct default_case_ < tag::meta_2ary_fun_operator, - mlc::valist_<E, A1, A2> > - { - typedef xtd_res_2(E, A1, A2) res; - - static res impl(const abstract::meta_nary_fun_<2, E>* this_, - const A1& a1, const A2& a2) - { - return exact_of(this_)->impl_calc(a1, a2); - } - }; - - - // meta_nary_fun_<3, E>::operator()(const A1& a1, const A2& a2, const A3& a3) const - - template <typename E, typename A1, typename A2, typename A3> - struct default_case_ < tag::meta_3ary_fun_operator, - mlc::valist_<E, A1, A2, A3> > - { - typedef xtd_res_3(E, A1, A2, A3) res; - - static res impl(const abstract::meta_nary_fun_<3, E>* this_, - const A1& a1, const A2& a2, const A3& a3) - { - return exact_of(this_)->impl_calc(a1, a2, a3); - } - }; - - -} // end of namespace xtd - - - - -namespace xtd -{ namespace abstract { @@ -157,206 +69,6 @@ }; - /*! \class xtd::abstract::meta_nary_fun_<n, E> - ** - ** Abstract base class for meta functions with an explicit number - ** of arguments. - ** - ** Parameter n is the number of arguments with n being 1, 2, or 3. - ** - ** Parameter E is the exact type of the function. - */ - - template <unsigned n, typename E> - class meta_nary_fun_; - - - - /*! \class xtd::abstract::meta_nary_fun_<0, E> - ** - ** Abstract base class for meta functions taking no argument. - ** This class is defined as a specialization. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class meta_nary_fun_< 0, E > - - : public meta_fun_<E>, - public nary_fun_<0> - { - public: - - /* - ** This member is not templated so its behavior at compile-time - ** is different than meta_nary_fun_<n,E>::operator() where n > - ** 0. Here the return type should be known before the hierarchy - ** classes are fully compiled thus static assertions in the - ** macro xtd_res_0 do *not* work. An alternate macro is thus - ** in use. - */ - - xtd_internal_res_0(E) - operator()() const - { - return exact_of(this)->impl_calc(); - } - - protected: - meta_nary_fun_() {} - }; - - - - /*! \class xtd::abstract::meta_nary_fun_<1, E> - ** - ** Abstract base class for meta functions taking one argument. - ** This class is defined as a specialization. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class meta_nary_fun_< 1, E > - - : public meta_fun_<E>, - public nary_fun_<1> - { - public: - - template <typename A> - struct case_ - - : private mlc::assert_< mlc_is_not_a(A, xtd::abstract::plain_fun_), - xtd::ERROR::ARG_SHOULD_NOT_BE_A_PLAIN_FUN >, - - private mlc::assert_< mlc::implies_< mlc_is_a(A, xtd::abstract::meta_fun_), - mlc_is_a(A, xtd::abstract::fun_expr_) >, - xtd::ERROR::ARG_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, - - public xtd::case_< xtd::tag::meta_1ary_fun_operator, - mlc::pair_<E, A> >::ret - {}; - - template <typename A> - typename case_<A>::res - operator()(const A& a) const - { - return case_<A>::impl(this, a); - } - - protected: - meta_nary_fun_() {} - }; - - - - /*! \class xtd::abstract::meta_nary_fun_<2, E> - ** - ** Abstract base class for meta functions taking two arguments. - ** This class is defined as a specialization. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class meta_nary_fun_< 2, E > - - : public meta_fun_<E>, - public nary_fun_<2> - { - public: - - template <typename A1, typename A2> - struct case_ - - : private mlc::assert_< mlc_is_not_a(A1, xtd::abstract::plain_fun_), - xtd::ERROR::ARG1_SHOULD_NOT_BE_A_PLAIN_FUN >, - - private mlc::assert_< mlc::implies_< mlc_is_a(A1, xtd::abstract::meta_fun_), - mlc_is_a(A1, xtd::abstract::fun_expr_) >, - xtd::ERROR::ARG1_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, - - private mlc::assert_< mlc_is_not_a(A2, xtd::abstract::plain_fun_), - xtd::ERROR::ARG2_SHOULD_NOT_BE_A_PLAIN_FUN >, - - private mlc::assert_< mlc::implies_< mlc_is_a(A2, xtd::abstract::meta_fun_), - mlc_is_a(A2, xtd::abstract::fun_expr_) >, - xtd::ERROR::ARG2_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, - - public xtd::case_< xtd::tag::meta_2ary_fun_operator, - mlc::valist_<E, A1, A2> >::ret - {}; - - template <typename A1, typename A2> - typename case_<A1, A2>::res - operator()(const A1& a1, const A2& a2) const - { - return case_<A1, A2>::impl(this, a1, a2); - } - - protected: - meta_nary_fun_() {} - }; - - - /*! \class xtd::abstract::meta_nary_fun_<3, E> - ** - ** Abstract base class for meta functions taking three arguments. - ** This class is defined as a specialization. - ** - ** Parameter E is the exact type of the function. - */ - - template <typename E> - class meta_nary_fun_< 3, E > - - : public meta_fun_<E>, - public nary_fun_<3> - { - public: - - template <typename A1, typename A2, typename A3> - struct case_ - - : private mlc::assert_< mlc_is_not_a(A1, xtd::abstract::plain_fun_), - xtd::ERROR::ARG1_SHOULD_NOT_BE_A_PLAIN_FUN >, - - private mlc::assert_< mlc::implies_< mlc_is_a(A1, xtd::abstract::meta_fun_), - mlc_is_a(A1, xtd::abstract::fun_expr_) >, - xtd::ERROR::ARG1_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, - - private mlc::assert_< mlc_is_not_a(A2, xtd::abstract::plain_fun_), - xtd::ERROR::ARG2_SHOULD_NOT_BE_A_PLAIN_FUN >, - - private mlc::assert_< mlc::implies_< mlc_is_a(A2, xtd::abstract::meta_fun_), - mlc_is_a(A2, xtd::abstract::fun_expr_) >, - xtd::ERROR::ARG2_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, - - private mlc::assert_< mlc_is_not_a(A3, xtd::abstract::plain_fun_), - xtd::ERROR::ARG3_SHOULD_NOT_BE_A_PLAIN_FUN >, - - private mlc::assert_< mlc::implies_< mlc_is_a(A3, xtd::abstract::meta_fun_), - mlc_is_a(A3, xtd::abstract::fun_expr_) >, - xtd::ERROR::ARG3_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, - - public xtd::case_< xtd::tag::meta_3ary_fun_operator, - mlc::valist_<E, A1, A2, A3> >::ret - {}; - - template <typename A1, typename A2, typename A3> - typename case_<A1, A2, A3>::res - operator()(const A1& a1, const A2& a2, const A3& a3) const - { - return case_<A1, A2, A3>::impl(this, a1, a2, a3); - } - - protected: - meta_nary_fun_() {} - }; - - } // end of namespace xtd::abstract } // end of namespace xtd Index: xtd/abstract/fun_nary_expr.hh --- xtd/abstract/fun_nary_expr.hh (revision 0) +++ xtd/abstract/fun_nary_expr.hh (revision 0) @@ -0,0 +1,234 @@ +// Copyright (C) 2002, 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 +// 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 EXTENDED_ABSTRACT_FUN_NARY_EXPR_HH +# define EXTENDED_ABSTRACT_FUN_NARY_EXPR_HH + +# include <xtd/abstract/fun_expr.hh> +# include <xtd/abstract/open_nary_fun.hh> + + + +namespace xtd +{ + + + /// Forward declarations. + /// \{ + + template <typename F, typename Expr1, typename Expr2> + struct m2expr_; + + template <typename F, typename Expr1, typename Expr2, typename Expr3> + struct m3expr_; + + template <typename T> + struct literal_expr_; + + template <unsigned i> + struct arg_; + + /// \} + + + + + namespace abstract + { + + /*! \class xtd::abstract::fun_nary_expr_<n, E> + ** + ** Abstract base class for function expressions with an explicit + ** number of arguments. + ** + ** For "open_nary_fun_<n, E>::operator()(arg1,...)" we provide + ** "::impl_calc(arg1,...)". This method first packs the argument list: + ** precisely "(arg1,...)" becomes "(arglist)" where the type of + ** "arglist" is "args_<Arg1,...>". Then the computation is delegated + ** to "fun_expr_<E>::eval(arglist)". + ** + ** Parameter n is the number of arguments with n being 0, 1, 2, or + ** 3. Parameter E is the exact type of the function. + */ + + template <unsigned n, typename E> + class fun_nary_expr_; + + + + /*! \class xtd::abstract::fun_nary_expr_<0, E> + ** + ** Abstract base class for function expressions taking no + ** argument. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class fun_nary_expr_< 0, E > + + : public fun_expr_<E>, + public open_nary_fun_<0, E> + { + public: + + // the return type here is not xtd_res_0(E) + // the explanations are given with meta_nary_fun_<0, E>::operator()() + // in file xtd/abstract/meta_fun.hh + + xtd_internal_res_0(E) + impl_calc() const + { + return this->eval(mk_args()); + } + + // no bind_i method here + + protected: + fun_nary_expr_() {} + }; + + + + /*! \class xtd::abstract::fun_nary_expr_<1, E> + ** + ** Abstract base class for function expressions taking one + ** argument. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class fun_nary_expr_< 1, E > + + : public fun_expr_<E>, + public open_nary_fun_<1, E> + { + public: + + template <typename A> + xtd_res_1(E, A) + impl_calc(const A& a) const + { + return this->eval(mk_args(a)); + } + + // no bind_i method here + + protected: + fun_nary_expr_() {} + }; + + + + /*! \class xtd::abstract::fun_nary_expr_<2, E> + ** + ** Abstract base class for function expressions taking two + ** arguments. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class fun_nary_expr_< 2, E > + + : public fun_expr_<E>, + public open_nary_fun_<2, E> + { + public: + + template <typename A1, typename A2> + xtd_res_2(E, A1, A2) + impl_calc(const A1& a1, const A2& a2) const + { + return this->eval(mk_args(a1, a2)); + } + + template <typename T> + m2expr_< E, literal_expr_<T>, arg_<2> > + bind_1(const T& value) const; + + template <typename T> + m2expr_< E, arg_<1>, literal_expr_<T> > + bind_2(const T& value) const; + + protected: + fun_nary_expr_() {} + }; + + + + /*! \class xtd::abstract::fun_nary_expr_<3, E> + ** + ** Abstract base class for function expressions taking three + ** arguments. + ** + ** Parameter E is the exact type of the function. + */ + + template <typename E> + class fun_nary_expr_< 3, E > + + : public fun_expr_<E>, + public open_nary_fun_<3, E> + { + public: + + template <typename A1, typename A2, typename A3> + xtd_res_3(E, A1, A2, A3) + impl_calc(const A1& a1, const A2& a2, const A3& a3) const + { + return this->eval(mk_args(a1, a2, a3)); + } + + template <typename T> + m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > + bind_1(const T& value) const; + + template <typename T> + m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > + bind_2(const T& value) const; + + template <typename T> + m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > + bind_3(const T& value) const; + + protected: + fun_nary_expr_() {} + }; + + + } // end of namespace xtd::abstract + + +} // end of namespace xtd + + +# include <xtd/bind.hh> + + +#endif // ! EXTENDED_ABSTRACT_FUN_NARY_EXPR_HH Index: xtd/mfun.hh --- xtd/mfun.hh (revision 441) +++ xtd/mfun.hh (working copy) @@ -28,12 +28,8 @@ #ifndef EXTENDED_MFUN_HH # define EXTENDED_MFUN_HH -# include <mlc/assert.hh> -# include <mlc/logic.hh> -# include <mlc/is_a.hh> - # include <xtd/abstract/plain_fun.hh> -# include <xtd/abstract/meta_fun.hh> +# include <xtd/abstract/meta_nary_fun.hh> Index: xtd/TODO --- xtd/TODO (revision 0) +++ xtd/TODO (revision 0) @@ -0,0 +1,5 @@ + -*- outline -*- + +* files + +xtd/res.hh -> xtd/internal/res.hh ? Index: xtd/arg.hh --- xtd/arg.hh (revision 441) +++ xtd/arg.hh (working copy) @@ -28,12 +28,7 @@ #ifndef EXTENDED_ARG_HH # define EXTENDED_ARG_HH -# include <mlc/assert.hh> -# include <mlc/is_a.hh> - -# include <xtd/args.hh> -# include <xtd/mexpr.hh> - +# include <xtd/abstract/fun_nary_expr.hh> namespace xtd @@ -122,7 +117,7 @@ template <unsigned i> struct arg_ - : public abstract::nary_fun_expr_< i, arg_ >, + : public abstract::fun_nary_expr_< i, arg_ >, public internal::impl_arg_ Index: xtd/bind.hh --- xtd/bind.hh (revision 0) +++ xtd/bind.hh (revision 0) @@ -0,0 +1,105 @@ +// Copyright (C) 2002, 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 +// 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 EXTENDED_BIND_HH +# define EXTENDED_BIND_HH + +# include <xtd/abstract/fun_nary_expr.hh> +# include <xtd/literal.hh> +# include <xtd/mexpr.hh> +# include <xtd/arg.hh> + + +namespace xtd +{ + + + namespace abstract + { + + // fun_nary_expr_< 2, E >::bind_i + + template <typename E> + template <typename T> + m2expr_< E, literal_expr_<T>, arg_<2> > + fun_nary_expr_< 2, E >::bind_1(const T& value) const + { + typedef m2expr_< E, literal_expr_<T>, arg_<2> > ret; + ret tmp(this->exact(), lit(value), arg_<2>()); + return tmp; + } + + template <typename E> + template <typename T> + m2expr_< E, arg_<1>, literal_expr_<T> > + fun_nary_expr_< 2, E >::bind_2(const T& value) const + { + typedef m2expr_< E, arg_<1>, literal_expr_<T> > ret; + ret tmp(this->exact(), arg_<1>(), lit(value)); + return tmp; + } + + + // fun_nary_expr_< 3, E >::bind_i + + template <typename E> + template <typename T> + m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > + fun_nary_expr_< 3, E >::bind_1(const T& value) const + { + typedef m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > ret; + ret tmp(this->exact(), lit(value), arg_<2>(), arg_<3>()); + return tmp; + } + + template <typename E> + template <typename T> + m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > + fun_nary_expr_< 3, E >::bind_2(const T& value) const + { + typedef m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > ret; + ret tmp(this->exact(), arg_<1>(), lit(value), arg_<3>()); + return tmp; + } + + template <typename E> + template <typename T> + m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > + fun_nary_expr_< 3, E >::bind_3(const T& value) const + { + typedef m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > ret; + ret tmp(this->exact(), arg_<1>(), arg_<2>(), lit(value)); + return tmp; + } + + } // end of namespace xtd::abstract + +} // end of namespace xtd + + + +#endif // ! EXTENDED_BIND_HH Index: xtd/internal/mlc.hh --- xtd/internal/mlc.hh (revision 0) +++ xtd/internal/mlc.hh (revision 0) @@ -0,0 +1,54 @@ +// Copyright (C) 2002, 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 +// 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 EXTENDED_INTERNAL_MLC_HH +# define EXTENDED_INTERNAL_MLC_HH + +# include <mlc/flags.hh> +# include <mlc/comma.hh> + +# include <mlc/typedef.hh> +# include <mlc/ret.hh> + +# include <mlc/assert.hh> +# include <mlc/is_a.hh> +# include <mlc/logic.hh> +# include <mlc/cmp.hh> +# include <mlc/if.hh> + +# include <mlc/pair.hh> +# include <mlc/valist.hh> + + + + +# include <mlc/case.hh> + +mlc_case_equipment_for_namespace(xtd); + + +#endif // ! EXTENDED_INTERNAL_MLC_HH Index: tests/id.cc --- tests/id.cc (revision 441) +++ tests/id.cc (working copy) @@ -1,6 +1,5 @@ #include <iostream> - #include <xtd/math/id.hh> Index: tests/bind.cc --- tests/bind.cc (revision 441) +++ tests/bind.cc (working copy) @@ -13,9 +13,9 @@ (_1 + _2)(_1, lit(1.f)); - (_1 + _2).bind_2(1.f); + ; - std::cout << (_1 + _2)(5., 1.) << std::endl; + std::cout << (_1 + _2) .bind_2(2.6f) (2.5f) << std::endl; // std::cout << (_1 + _2)(_1, 1.)(5.) << std::endl; Index: tests/lit.cc --- tests/lit.cc (revision 441) +++ tests/lit.cc (working copy) @@ -1,4 +1,5 @@ #include <iostream> + #include <xtd/literal.hh>

1 0

Re: [Olena-patches] proto-1.0 435: Add GPL License to trunk.
by Robert Bigaignon 24 Mar '06

24 Mar '06

Nicolas Widynski wrote: > https://svn/svn/oln/prototypes/proto-1.0 > > Index: ChangeLog > from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> > > Add GPL License to trunk. > > * COPYING: New. GNU Free Documentation License. > Nice...

4 3

proto-1.0 441: Clean up olena/ChangeLog.
by Roland Levillain 24 Mar '06

24 Mar '06

https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 Please wrap lines longer than 80 columns whenever possible! TIA. Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> * olena/ChangeLog: Clean up. ChangeLog | 73 ++++++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 43 insertions(+), 30 deletions(-) Index: olena/ChangeLog --- olena/ChangeLog (revision 440) +++ olena/ChangeLog (working copy) @@ -1,9 +1,15 @@ +2005-08-29 Roland Levillain <roland(a)lrde.epita.fr> + + * oln/morpho/shortest_path_watershed.hh + (shortest_path_watershed_): Fix comment. + 2006-03-09 Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> - Watersnakes : add reconstruction by erosion with tarjan union-find. + Watersnakes: add reconstruction by erosion with Tarjan's + union-find. - * oln/morpho/watersnakes.hh: Add reconstruction by erosion with tarjan - union-find (quicker). + * oln/morpho/watersnakes.hh: Add reconstruction by erosion with + Tarjan's union-find (quicker). 2006-03-09 Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> @@ -25,33 +31,36 @@ Implementation of Image Inpainting algorithm in Olena 0.10. * oln/convolution/laplacian_olena_0_10.hh: New. Laplacian 2d. - * oln/level/anisotropic_diffusion_olena_0_10.hh: New. Anisotropic diffusion - from Perona Malik. - * oln/morpho/gradient_morpho_olena_0_10.hh: New. Morphological gradient. - * oln/appli/inpainting/image_inpainting_olena_0_10.hh: New. Image inpainting - algorithm from Bertalmio. + * oln/level/anisotropic_diffusion_olena_0_10.hh: New. Anisotropic + diffusion from Perona Malik. + * oln/morpho/gradient_morpho_olena_0_10.hh: New. Morphological + gradient. + * oln/appli/inpainting/image_inpainting_olena_0_10.hh: New. Image + inpainting algorithm from Bertalmio. 2006-02-15 Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Implementation of image inpainting algorithm in Olena 0.10. * oln/convolution/laplacian_olena_0_10.hh: New. Laplacian 2d. - * oln/level/anisotropic_diffusion_olena_0_10.hh: New. Anisotropic diffusion - from Perona Malik. - * oln/morpho/gradient_morpho_olena_0_10.hh: New. Morphological gradiant. - * oln/appli/inpainting/image_inpainting_olena_0_10.hh: New. Image inpainting - from Bertalmio. + * oln/level/anisotropic_diffusion_olena_0_10.hh: New. Anisotropic + diffusion from Perona Malik. + * oln/morpho/gradient_morpho_olena_0_10.hh: New. Morphological + gradiant. + * oln/appli/inpainting/image_inpainting_olena_0_10.hh: New. Image + inpainting from Bertalmio. 2006-02-15 Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> Implementation of image inpainting algorithm in Olena 0.10. * oln/convolution/laplacian_olena_0_10.hh: New. Laplacian 2d. - * oln/level/anisotropic_diffusion_olena_0_10.hh: New. Anisotropic diffusion - from Perona Malik. - * oln/morpho/gradient_morpho_olena_0_10.hh: New. Morphological gradiant. - * oln/appli/inpainting/image_inpainting_olena_0_10.hh: New. Image inpainting - from Bertalmio. + * oln/level/anisotropic_diffusion_olena_0_10.hh: New. Anisotropic + diffusion from Perona Malik. + * oln/morpho/gradient_morpho_olena_0_10.hh: New. Morphological + gradiant. + * oln/appli/inpainting/image_inpainting_olena_0_10.hh: New. Image + inpainting from Bertalmio. 2006-02-13 Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> @@ -62,7 +71,8 @@ 2006-02-12 Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> - Util function : set outsides boundaries at the same value of image boundaries. + Util function : set outsides boundaries at the same value of image + boundaries. * oln/utils/clean_boundaries.hh: New. To clean image boundaries. @@ -70,7 +80,8 @@ Add Image Inpainting algorithm. - * oln/appli/inpainting/image_inpainting.hh: New. Based on Bertalmio algorithm. + * oln/appli/inpainting/image_inpainting.hh: New. Based on + Bertalmio algorithm. 2006-02-10 Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> @@ -82,7 +93,8 @@ Add anisotropic diffusion. - * oln/level/anisotropic_diffusion.hh: New. Anisotropic diffusion algorithm. + * oln/level/anisotropic_diffusion.hh: New. Anisotropic diffusion + algorithm. * oln/makefile.src: Add anisotropic_diffusion.hh to the makefile. 2006-02-09 Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> @@ -106,12 +118,13 @@ Update laplacian convolution. - * oln/convolution/laplacian.hh: Update laplacian convolution for first and - second derivatives. + * oln/convolution/laplacian.hh: Update laplacian convolution for + first and second derivatives. 2005-10-11 Damien Thivolle <damien(a)lrde.epita.fr> - Add grey level self-dual reconstruction and clean reconstruction classes. + Add grey level self-dual reconstruction and clean reconstruction + classes. * tests/morpho/tests/reconstruction: Remove. Split into two files (binary and grey level). @@ -133,16 +146,16 @@ * tests/morpho/tests/reconstruction: Now use builtin types. * oln/funobj/invert.hh: Add bool and unsigned char inversion. - * oln/core/abstract/image_typeness.hh: Add rules (unsigned char, char and - ntg::real_value) for greylevel_image. + * oln/core/abstract/image_typeness.hh: Add rules (unsigned char, + char and ntg::real_value) for greylevel_image. * oln/morpho/reconstruction.hh: Now support grey level images. * oln/morpho/local.hh: Add new functions for handling neighborhood. - * oln/morpho/reconstruction_by_dilation.hh: Add grey level specialization - and use new functions from local.hh. + * oln/morpho/reconstruction_by_dilation.hh: Add grey level + specialization and use new functions from local.hh. * oln/morpho/reconstruction_selfdual.hh: Likewise. * oln/morpho/reconstruction_by_erosion.hh: Likewise. - * oln/canvas/reconstruction.hh: Now use mlc::is_a to check if the input - images have a neighborhood. A bit of cleaning. + * oln/canvas/reconstruction.hh: Now use mlc::is_a to check if the + input images have a neighborhood. A bit of cleaning. 2005-09-14 Thierry GERAUD <theo(a)lrde.epita.fr>

1 0

440: Add material for literals, binding arguments, and static checks.
by Thierry Geraud 24 Mar '06

24 Mar '06

https://svn.lrde.epita.fr/svn/oln/trunk/extended Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Add material for literals, binding arguments, and static checks. * xtd/res.hh (xtd_res_0_ et al.): New; versions without typename. (xtd_internal_res_0, internal::get_res_0_unchecked): New; this equipment is for use in hierarchies to avoid partial definitions. * xtd/mexpr.hh: Add static assertions. * xtd/literal.hh (literal_): Rename as... (plain_literal_): ...this. (meta_literal_): New class. (literal_expr_): Add static assertions. (lit): New routine. (bind_1, bind_2, bind_3): New; method implementation for nary_fun_expr_<n, E>::bind_i. * xtd/arg.hh (xtd_nargs): Remove this duplicate. * xtd/args.hh (xtd_nargs, nargs_): Move to... * xtd/abstract/fun_expr.hh: ...this file. (fun_expr_<E>::nargs): Remove; xtd_nargs does it. (xtd_res_0): Replace by... (xtd_internal_res_0): ...this. (bind_1, bind_2, bind_3): New methods. * xtd/abstract/exact.hh: Remove; the routine exact_of has moved... * xtd/abstract/fun.hh: ...here. * xtd/abstract/plain_fun.hh (operator()): Add static check. * xtd/abstract/meta_fun.hh: Add static checks. * tests/id.cc: Add xfail tests. * tests/bind.cc: New. * tests/lit.cc: New. * tests/Makefile.am: Update. tests/Makefile.am | 6 + tests/bind.cc | 25 ++++++++ tests/id.cc | 4 - tests/lit.cc | 25 ++++++++ xtd/abstract/fun.hh | 17 +++++ xtd/abstract/fun_expr.hh | 116 +++++++++++++++++++++++++++++++++++-- xtd/abstract/meta_fun.hh | 86 ++++++++++++++++++++++++++-- xtd/abstract/plain_fun.hh | 28 ++++++++- xtd/arg.hh | 6 - xtd/args.hh | 31 ++-------- xtd/literal.hh | 141 ++++++++++++++++++++++++++++++++++++++++++++-- xtd/mexpr.hh | 109 +++++++++++++++++++++++++++++++---- xtd/res.hh | 21 ++++++ 13 files changed, 552 insertions(+), 63 deletions(-) Index: xtd/res.hh --- xtd/res.hh (revision 439) +++ xtd/res.hh (working copy) @@ -82,11 +82,25 @@ // macros # define xtd_res_0(F) typename xtd::internal::get_res_<F>::ret +# define xtd_res_0_(F) xtd::internal::get_res_<F>::ret + # define xtd_res_1(F, A1) typename xtd::internal::get_res_<F, A1>::ret +# define xtd_res_1_(F, A1) xtd::internal::get_res_<F, A1>::ret + # define xtd_res_2(F, A1, A2) typename xtd::internal::get_res_<F, A1, A2>::ret +# define xtd_res_2_(F, A1, A2) xtd::internal::get_res_<F, A1, A2>::ret + # define xtd_res_3(F, A1, A2, A3) typename xtd::internal::get_res_<F, A1, A2, A3>::ret +# define xtd_res_3_(F, A1, A2, A3) xtd::internal::get_res_<F, A1, A2, A3>::ret # define xtd_expr_res(F, Args) typename xtd::internal::get_expr_res_<F, Args>::ret +# define xtd_expr_res_(F, Args) xtd::internal::get_expr_res_<F, Args>::ret + + + +// internal so do not use it; prefer xtd_res_0(F) +# define xtd_internal_res_0(F) typename xtd::internal::get_res_0_unchecked<F>::ret + namespace xtd @@ -198,6 +212,13 @@ }; + template <typename F> + struct get_res_0_unchecked + { + typedef mlc_ret(xtd::res_<F>) ret; + }; + + // a single arg template <typename F, typename A1> Index: xtd/mexpr.hh --- xtd/mexpr.hh (revision 439) +++ xtd/mexpr.hh (working copy) @@ -30,12 +30,14 @@ # include <mlc/case.hh> # include <mlc/assert.hh> +# include <mlc/logic.hh> # include <mlc/is_a.hh> -# include <xtd/args.hh> -# include <xtd/res.hh> # include <xtd/abstract/nary_fun.hh> # include <xtd/abstract/fun_expr.hh> +# include <xtd/args.hh> +# include <xtd/res.hh> +# include <xtd/literal.hh> @@ -47,6 +49,13 @@ namespace ERROR { + struct MIXED_ARGUMENTS_IN_CALLING_A_BINARY_META_FUNCTION__EXPR_VALUE; + struct MIXED_ARGUMENTS_IN_CALLING_A_BINARY_META_FUNCTION__VALUE_EXPR; + + struct MIXED_ARGUMENTS_IN_CALLING_A_TERNARY_META_FUNCTION__EXPR1; + struct MIXED_ARGUMENTS_IN_CALLING_A_TERNARY_META_FUNCTION__EXPR2; + struct MIXED_ARGUMENTS_IN_CALLING_A_TERNARY_META_FUNCTION__EXPR3; + struct FIXME; } // end of namespace xtd::ERROR @@ -86,7 +95,13 @@ template <typename F> struct m0expr_ - : public abstract::nary_fun_expr_< 0, m0expr_<F> > + : private mlc::assert_< mlc_is_a(F, abstract::nary_fun_<0>), + ERROR::FIXME >, + + private mlc::assert_< mlc_is_a(F, abstract::meta_fun_), + ERROR::FIXME >, + + public abstract::nary_fun_expr_< 0, m0expr_<F> > { const F f; @@ -120,6 +135,9 @@ template <typename F, typename Expr> struct nargs_< m1expr_<F, Expr> > + + : private mlc::assert_< mlc_is_a(Expr, abstract::fun_expr_), + xtd::ERROR::FIXME > { static const unsigned ret = xtd_nargs(Expr); }; @@ -141,7 +159,16 @@ typename Expr> struct m1expr_ - : public abstract::nary_fun_expr_< xtd_nargs(Expr), + : private mlc::assert_< mlc_is_a(F, abstract::nary_fun_<1>), + ERROR::FIXME >, + + private mlc::assert_< mlc_is_a(F, abstract::meta_fun_), + ERROR::FIXME >, + + private mlc::assert_< mlc_is_a(Expr, abstract::fun_expr_), + xtd::ERROR::FIXME >, + + public abstract::nary_fun_expr_< xtd_nargs(Expr), m1expr_<F, Expr> > { typedef m1expr_<F, Expr> self; @@ -159,7 +186,7 @@ expr(exact_of(expr)) {} - m1expr_(const F& f, + m1expr_(const F& f, // FIXME: constraint? const abstract::fun_expr_<Expr>& expr) : f(f), expr(exact_of(expr)) @@ -189,6 +216,10 @@ template <typename F, typename Expr1, typename Expr2> struct nargs_< m2expr_<F, Expr1, Expr2> > + + : private mlc::assert_< mlc::and_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr2, abstract::fun_expr_) >, + xtd::ERROR::FIXME > { static const unsigned ret = n_max< xtd_nargs(Expr1), xtd_nargs(Expr2) >::ret; @@ -212,7 +243,17 @@ typename Expr1, typename Expr2> struct m2expr_ - : public abstract::nary_fun_expr_< xtd_nargs(mlc_comma_2(m2expr_<F, Expr1, Expr2>)), + : private mlc::assert_< mlc_is_a(F, abstract::nary_fun_<2>), + ERROR::FIXME >, + + private mlc::assert_< mlc_is_a(F, abstract::meta_fun_), + ERROR::FIXME >, + + private mlc::assert_< mlc::and_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr2, abstract::fun_expr_) >, + xtd::ERROR::FIXME >, + + public abstract::nary_fun_expr_< xtd_nargs(mlc_comma_2(m2expr_<F, Expr1, Expr2>)), m2expr_<F, Expr1, Expr2> > { typedef m2expr_<F, Expr1, Expr2> self; @@ -264,6 +305,11 @@ template <typename F, typename Expr1, typename Expr2, typename Expr3> struct nargs_< m3expr_<F, Expr1, Expr2, Expr3> > + + : private mlc::assert_< mlc::and_list_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr2, abstract::fun_expr_), + mlc_is_a(Expr3, abstract::fun_expr_) >, + xtd::ERROR::FIXME > { static const unsigned ret = n_max< xtd_nargs(Expr1), n_max< xtd_nargs(Expr2), @@ -289,7 +335,18 @@ typename Expr1, typename Expr2, typename Expr3> struct m3expr_ - : public abstract::nary_fun_expr_< xtd_nargs(mlc_comma_3(m3expr_<F, Expr1, Expr2, Expr3>)), + : private mlc::assert_< mlc_is_a(F, abstract::nary_fun_<3>), + ERROR::FIXME >, + + private mlc::assert_< mlc_is_a(F, abstract::meta_fun_), + ERROR::FIXME >, + + private mlc::assert_< mlc::and_list_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr2, abstract::fun_expr_), + mlc_is_a(Expr3, abstract::fun_expr_) >, + xtd::ERROR::FIXME >, + + public abstract::nary_fun_expr_< xtd_nargs(mlc_comma_3(m3expr_<F, Expr1, Expr2, Expr3>)), m3expr_<F, Expr1, Expr2, Expr3> > { typedef m3expr_<F, Expr1, Expr2, Expr3> self; @@ -358,15 +415,25 @@ }; + // meta_nary_fun_<2, F>::operator()(const fun_expr_<Expr1>& expr1, // const fun_expr_<Expr2>& expr2) const + template <typename F, typename Expr1, typename Expr2> struct case_< tag::meta_2ary_fun_operator, mlc::valist_<F, Expr1, Expr2>, 1 > - : public mlc::where_< mlc::and_< mlc_is_a(Expr1, abstract::fun_expr_), - mlc_is_a(Expr2, abstract::fun_expr_) > > + : public mlc::where_< mlc::or_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr2, abstract::fun_expr_) > >, + + private mlc::assert_< mlc::implies_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr2, abstract::fun_expr_) >, + xtd::ERROR::MIXED_ARGUMENTS_IN_CALLING_A_BINARY_META_FUNCTION__EXPR_VALUE >, + + private mlc::assert_< mlc::implies_< mlc_is_a(Expr2, abstract::fun_expr_), + mlc_is_a(Expr1, abstract::fun_expr_) >, + xtd::ERROR::MIXED_ARGUMENTS_IN_CALLING_A_BINARY_META_FUNCTION__VALUE_EXPR > { typedef m2expr_<F, Expr1, Expr2> res; @@ -377,9 +444,11 @@ res tmp(exact_of(*this_), expr1, expr2); return tmp; } + }; + // meta_nary_fun_<3, F>::operator()(const fun_expr_<Expr1>& expr1, // const fun_expr_<Expr2>& expr2, // const fun_expr_<Expr3>& expr3) const @@ -388,9 +457,27 @@ struct case_< tag::meta_3ary_fun_operator, mlc::valist_<F, Expr1, Expr2, Expr3>, 1 > - : public mlc::where_< mlc::and_< mlc_is_a(Expr1, abstract::fun_expr_), + : public mlc::where_< mlc::or_list_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr2, abstract::fun_expr_), + mlc_is_a(Expr3, abstract::fun_expr_) > >, + + // FIXME: try to get more precise error detections below... + + private mlc::assert_< mlc::implies_< mlc_is_a(Expr1, abstract::fun_expr_), mlc::and_< mlc_is_a(Expr2, abstract::fun_expr_), - mlc_is_a(Expr3, abstract::fun_expr_) > > > + mlc_is_a(Expr3, abstract::fun_expr_) > >, + xtd::ERROR::MIXED_ARGUMENTS_IN_CALLING_A_TERNARY_META_FUNCTION__EXPR1 >, + + private mlc::assert_< mlc::implies_< mlc_is_a(Expr2, abstract::fun_expr_), + mlc::and_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr3, abstract::fun_expr_) > >, + xtd::ERROR::MIXED_ARGUMENTS_IN_CALLING_A_TERNARY_META_FUNCTION__EXPR2 >, + + private mlc::assert_< mlc::implies_< mlc_is_a(Expr3, abstract::fun_expr_), + mlc::and_< mlc_is_a(Expr1, abstract::fun_expr_), + mlc_is_a(Expr2, abstract::fun_expr_) > >, + xtd::ERROR::MIXED_ARGUMENTS_IN_CALLING_A_TERNARY_META_FUNCTION__EXPR3 > + { typedef m3expr_<F, Expr1, Expr2, Expr3> res; Index: xtd/literal.hh --- xtd/literal.hh (revision 439) +++ xtd/literal.hh (working copy) @@ -28,32 +28,45 @@ #ifndef EXTENDED_LITERAL_HH # define EXTENDED_LITERAL_HH +# include <mlc/assert.hh> +# include <mlc/is_a.hh> + # include <xtd/abstract/plain_fun.hh> +# include <xtd/abstract/meta_fun.hh> +# include <xtd/abstract/fun_expr.hh> namespace xtd { - /*! \class xtd::literal_<T> + namespace ERROR + { + struct FIXME; + + } // end of namespace xtd::ERROR + + + + /*! \class xtd::plain_literal_<T> ** ** FIXME: doc */ - template <typename T> struct literal_; // fwd decl + template <typename T> struct plain_literal_; // fwd decl template <typename T> - struct fun_traits_< literal_<T> > + struct fun_traits_< plain_literal_<T> > { typedef T res_type; }; template <typename T> - struct literal_ : public abstract::plain_nary_fun_< 0, literal_<T> > + struct plain_literal_ : public abstract::plain_nary_fun_< 0, plain_literal_<T> > { const T value; - literal_(const T& value) + plain_literal_(const T& value) : value(value) {} @@ -65,6 +78,39 @@ + // equipment for xtd::meta_literal_<T> + + template <typename T> struct meta_literal_; // fwd decl + + template <typename T> + struct res_< meta_literal_<T> > + { + typedef T ret; + }; + + + /*! \class xtd::meta_literal_<T> + ** + ** FIXME: doc + */ + + template <typename T> + struct meta_literal_ : public abstract::meta_nary_fun_< 0, meta_literal_<T> > + { + const T value; + + meta_literal_(const T& value) + : value(value) + {} + + T impl_calc() const + { + return this->value; + } + }; + + + // literal as fun expression // FIXME: this should be the only version (?) // FIXME: we should remove the plain version (?) @@ -90,7 +136,10 @@ template <typename T> struct literal_expr_ - : public abstract::nary_fun_expr_< 0, literal_expr_<T> > + : private mlc::assert_< mlc_is_not_a(T, abstract::fun_), + xtd::ERROR::FIXME >, + + public abstract::nary_fun_expr_< 0, literal_expr_<T> > { const T value; @@ -106,6 +155,86 @@ }; + // FIXME: doc + + template <typename T> + literal_expr_<T> lit(const T& value) + { + literal_expr_<T> tmp(value); + return tmp; + } + + +} // end of namespace xtd + + +# include <xtd/mexpr.hh> +# include <xtd/arg.hh> + + +namespace xtd +{ + + namespace abstract + { + + // nary_fun_expr_< 2, E >::bind_i + + template <typename E> + template <typename T> + m2expr_< E, literal_expr_<T>, arg_<2> > + nary_fun_expr_< 2, E >::bind_1(const T& value) const + { + typedef m2expr_< E, literal_expr_<T>, arg_<2> > ret; + ret tmp(exact_of(this), lit(value), arg_<2>()); + return tmp; + } + + template <typename E> + template <typename T> + m2expr_< E, arg_<1>, literal_expr_<T> > + nary_fun_expr_< 2, E >::bind_2(const T& value) const + { + typedef m2expr_< E, arg_<1>, literal_expr_<T> > ret; + ret tmp(exact_of(this), arg_<1>(), lit(value)); + return tmp; + } + + + // nary_fun_expr_< 3, E >::bind_i + + template <typename E> + template <typename T> + m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > + nary_fun_expr_< 3, E >::bind_1(const T& value) const + { + typedef m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > ret; + ret tmp(exact_of(this), lit(value), arg_<2>(), arg_<3>()); + return tmp; + } + + template <typename E> + template <typename T> + m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > + nary_fun_expr_< 3, E >::bind_2(const T& value) const + { + typedef m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > ret; + ret tmp(exact_of(this), arg_<1>(), lit(value), arg_<3>()); + return tmp; + } + + template <typename E> + template <typename T> + m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > + nary_fun_expr_< 3, E >::bind_3(const T& value) const + { + typedef m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > ret; + ret tmp(exact_of(this), arg_<1>(), arg_<2>(), lit(value)); + return tmp; + } + + } // end of namespace xtd::abstract + } // end of namespace xtd Index: xtd/args.hh --- xtd/args.hh (revision 439) +++ xtd/args.hh (working copy) @@ -29,23 +29,22 @@ # define EXTENDED_ARGS_HH # include <mlc/flags.hh> - - - -// FIXME: doc -// FIXME: this code should be rewritten to check that -// FIXME: xtd::nargs_<F>::ret is properly defined; see for -// FIXME: instance, the code of xtd_res or xtd_arg1... - -# define xtd_nargs(F) xtd::nargs_<F>::ret +# include <mlc/assert.hh> +# include <mlc/is_a.hh> namespace xtd { + namespace abstract { + + // fwd decl + template <typename E> struct fun_expr_; + + /*! \class xtd::abstract::args ** ** FIXME: Abstract base class for args_<..> @@ -61,20 +60,6 @@ - - /*! \class xtd::nargs_<F> - ** - ** FIXME: doc - ** FIXME: and add a mechanism so that the type of F is checked - ** FIXME: Cf. get_res0_ in xtd/abstract/meta_fun.hh - */ - - template <typename F> - struct nargs_; - - - - /*! \class xtd::args_<A1, ..> ** ** FIXME: to pack arguments Index: xtd/abstract/fun_expr.hh --- xtd/abstract/fun_expr.hh (revision 439) +++ xtd/abstract/fun_expr.hh (working copy) @@ -28,17 +28,23 @@ #ifndef EXTENDED_ABSTRACT_FUN_EXPR_HH # define EXTENDED_ABSTRACT_FUN_EXPR_HH +# include <mlc/flags.hh> # include <mlc/bool.hh> # include <mlc/is_a.hh> # include <mlc/comma.hh> # include <xtd/args.hh> # include <xtd/res.hh> -# include <xtd/abstract/exact.hh> # include <xtd/abstract/meta_fun.hh> +// FIXME: doc + +# define xtd_nargs(F) xtd::internal::get_nargs_<F>::ret + + + namespace xtd { @@ -47,13 +53,74 @@ { struct INTERNAL_ILL_FORMED_CALL_TO_xtd_fun_expr_eval; + struct SPECIALIZATION_OF_xtd_nargs_IS_FOR_xtd_fun_expr_ONLY; + struct SPECIALIZATION_OF_xtd_nargs_NOT_FOUND_FOR_AN_xtd_fun_expr; } // end of namespace xtd::ERROR + + /// Forward declarations. + /// \{ + namespace abstract { + template <typename E> class fun_expr_; + } + + template <typename F, typename Expr1, typename Expr2> + struct m2expr_; + + template <typename F, typename Expr1, typename Expr2, typename Expr3> + struct m3expr_; + + template <typename T> + struct literal_expr_; + + template <unsigned i> + struct arg_; + + /// \} + + + + /*! \class xtd::nargs_<F> + ** + ** FIXME: doc + ** FIXME: and add a mechanism so that the type of F is checked + ** FIXME: Cf. get_res0_ in xtd/abstract/meta_fun.hh + */ + + template <typename F> + struct nargs_ : public mlc::undefined + { + }; + + + namespace internal + { + + template <typename F> + struct get_nargs_ + + : // private mlc::assert_< mlc_is_a(F, xtd::abstract::fun_expr_), + // xtd::ERROR::SPECIALIZATION_OF_xtd_nargs_IS_FOR_xtd_fun_expr_ONLY >, + // FIXME: the static assertion above does *not* compile... + + private mlc::assert_< mlc_is_not_a(xtd::nargs_<F>, mlc::undefined), + xtd::ERROR::SPECIALIZATION_OF_xtd_nargs_NOT_FOUND_FOR_AN_xtd_fun_expr > + { + static const unsigned ret = xtd::nargs_<F>::ret; + }; + + } // end of xtd::internal + + + + namespace abstract + { + /*! \class xtd::abstract::fun_expr_<E> ** @@ -74,8 +141,6 @@ { public: - // evaluation: - template <typename Args> xtd_expr_res(E, Args) eval(const Args& as) const @@ -85,15 +150,15 @@ return exact_of(this)->impl_eval(as); } - // FIXME: the get_nargs method is obsolete; remove it! - unsigned nargs() const { return xtd_nargs(E); } - protected: fun_expr_() {} }; + + + /*! \class xtd::abstract::nary_fun_expr_<n, E> ** ** Abstract base class for function expressions with an explicit @@ -125,10 +190,19 @@ public meta_nary_fun_<0, E> { public: - xtd_res_0(E) impl_calc() const + + // the return type here is not xtd_res_0(E) + // the explanations are given with meta_nary_fun_<0, E>::operator()() + // in file xtd/abstract/meta_fun.hh + + xtd_internal_res_0(E) + impl_calc() const { return this->eval(mk_args()); } + + // no bind_i method here + protected: nary_fun_expr_() {} }; @@ -150,12 +224,16 @@ public meta_nary_fun_<1, E> { public: + template <typename A> xtd_res_1(E, A) impl_calc(const A& a) const { return this->eval(mk_args(a)); } + + // no bind_i method here + protected: nary_fun_expr_() {} }; @@ -177,12 +255,22 @@ public meta_nary_fun_<2, E> { public: + template <typename A1, typename A2> xtd_res_2(E, A1, A2) impl_calc(const A1& a1, const A2& a2) const { return this->eval(mk_args(a1, a2)); } + + template <typename T> + m2expr_< E, literal_expr_<T>, arg_<2> > + bind_1(const T& value) const; + + template <typename T> + m2expr_< E, arg_<1>, literal_expr_<T> > + bind_2(const T& value) const; + protected: nary_fun_expr_() {} }; @@ -204,12 +292,26 @@ public meta_nary_fun_<3, E> { public: + template <typename A1, typename A2, typename A3> xtd_res_3(E, A1, A2, A3) impl_calc(const A1& a1, const A2& a2, const A3& a3) const { return this->eval(mk_args(a1, a2, a3)); } + + template <typename T> + m3expr_< E, literal_expr_<T>, arg_<2>, arg_<3> > + bind_1(const T& value) const; + + template <typename T> + m3expr_< E, arg_<1>, literal_expr_<T>, arg_<3> > + bind_2(const T& value) const; + + template <typename T> + m3expr_< E, arg_<1>, arg_<2>, literal_expr_<T> > + bind_3(const T& value) const; + protected: nary_fun_expr_() {} }; Index: xtd/abstract/fun.hh --- xtd/abstract/fun.hh (revision 439) +++ xtd/abstract/fun.hh (working copy) @@ -51,6 +51,23 @@ } // end of namespace xtd::abstract + + + // FIXME: doc + + template <typename E> + const E* exact_of(const abstract::fun_<E>* f) + { + return (const E*)(const void*)(f); + } + + template <typename E> + const E& exact_of(const abstract::fun_<E>& f) + { + return *(const E*)(const void*)(&f); + } + + } // end of namespace xtd Index: xtd/abstract/plain_fun.hh --- xtd/abstract/plain_fun.hh (revision 439) +++ xtd/abstract/plain_fun.hh (working copy) @@ -29,11 +29,12 @@ # define EXTENDED_ABSTRACT_PLAIN_FUN_HH # include <mlc/flags.hh> -# include <mlc/bool.hh> // FIXME: should be assert.hh +# include <mlc/assert.hh> # include <mlc/is_a.hh> # include <mlc/typedef.hh> +# include <mlc/assert.hh> +# include <mlc/abort.hh> -# include <xtd/abstract/exact.hh> # include <xtd/abstract/fun.hh> # include <xtd/abstract/nary_fun.hh> @@ -70,18 +71,24 @@ struct YOU_SHOULD_NOT_DERIVE_FROM_xtd_plain_fun_BUT_FROM_xtd_plain_nary_fun; + struct FIXME; + + struct AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT; + // FIXME: add error messages corresponding to definitions without sense // FIXME: such as having arg2 when the plain function is unary } // end of namespace xtd::ERROR + template <typename F> struct fun_traits_ : public mlc::undefined { // nothing }; + mlc_decl_typedef(arg_type); mlc_decl_typedef(arg1_type); @@ -94,8 +101,12 @@ namespace abstract { - // fwd decl + /// Forward declarations. + /// \{ template <unsigned n, typename E> class plain_nary_fun_; + template <typename E> class meta_fun_; + template <typename E> class fun_expr_; + /// \} @@ -157,10 +168,12 @@ public nary_fun_<0> { public: + xtd_res(E) operator()() const { return exact_of(this)->impl_op(); } + protected: plain_nary_fun_() {} }; @@ -185,10 +198,19 @@ xtd::ERROR::xtd_fun_traits_SHOULD_DEFINE_arg_type_FOR_AN_xtd_plain_nary_fun_WITH_n_BEING_1 > { public: + + template <typename F> + void operator()(const abstract::fun_<F>&) const + { + mlc::abort_< F, + xtd::ERROR::AN_xtd_plain_function_DOES_NOT_ACCEPT_AN_xtd_function_AS_ARGUMENT >::check(); + } + xtd_res(E) operator()(const xtd_arg(E)& arg) const { return exact_of(this)->impl_op(arg); } + protected: plain_nary_fun_() {} }; Index: xtd/abstract/meta_fun.hh --- xtd/abstract/meta_fun.hh (revision 439) +++ xtd/abstract/meta_fun.hh (working copy) @@ -28,10 +28,10 @@ #ifndef EXTENDED_ABSTRACT_META_FUN_HH # define EXTENDED_ABSTRACT_META_FUN_HH +# include <mlc/flags.hh> # include <mlc/pair.hh> # include <mlc/valist.hh> -# include <xtd/abstract/exact.hh> # include <xtd/abstract/fun.hh> # include <xtd/abstract/nary_fun.hh> # include <xtd/args.hh> @@ -46,6 +46,23 @@ namespace xtd { + + namespace ERROR + { + struct ARG_SHOULD_NOT_BE_A_PLAIN_FUN; + struct ARG1_SHOULD_NOT_BE_A_PLAIN_FUN; + struct ARG2_SHOULD_NOT_BE_A_PLAIN_FUN; + struct ARG3_SHOULD_NOT_BE_A_PLAIN_FUN; + + struct ARG_SHOULD_NOT_BE_A_META_NON_EXPR_FUN; + struct ARG1_SHOULD_NOT_BE_A_META_NON_EXPR_FUN; + struct ARG2_SHOULD_NOT_BE_A_META_NON_EXPR_FUN; + struct ARG3_SHOULD_NOT_BE_A_META_NON_EXPR_FUN; + + }// end of namespace xtd + + + // FIXME: document case stuff... namespace tag @@ -109,6 +126,8 @@ } // end of namespace xtd + + namespace xtd { @@ -169,7 +188,16 @@ { public: - xtd_res_0(E) + /* + ** This member is not templated so its behavior at compile-time + ** is different than meta_nary_fun_<n,E>::operator() where n > + ** 0. Here the return type should be known before the hierarchy + ** classes are fully compiled thus static assertions in the + ** macro xtd_res_0 do *not* work. An alternate macro is thus + ** in use. + */ + + xtd_internal_res_0(E) operator()() const { return exact_of(this)->impl_calc(); @@ -198,7 +226,16 @@ public: template <typename A> - struct case_ : public xtd::case_< xtd::tag::meta_1ary_fun_operator, + struct case_ + + : private mlc::assert_< mlc_is_not_a(A, xtd::abstract::plain_fun_), + xtd::ERROR::ARG_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc::implies_< mlc_is_a(A, xtd::abstract::meta_fun_), + mlc_is_a(A, xtd::abstract::fun_expr_) >, + xtd::ERROR::ARG_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, + + public xtd::case_< xtd::tag::meta_1ary_fun_operator, mlc::pair_<E, A> >::ret {}; @@ -232,7 +269,23 @@ public: template <typename A1, typename A2> - struct case_ : public xtd::case_< xtd::tag::meta_2ary_fun_operator, + struct case_ + + : private mlc::assert_< mlc_is_not_a(A1, xtd::abstract::plain_fun_), + xtd::ERROR::ARG1_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc::implies_< mlc_is_a(A1, xtd::abstract::meta_fun_), + mlc_is_a(A1, xtd::abstract::fun_expr_) >, + xtd::ERROR::ARG1_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, + + private mlc::assert_< mlc_is_not_a(A2, xtd::abstract::plain_fun_), + xtd::ERROR::ARG2_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc::implies_< mlc_is_a(A2, xtd::abstract::meta_fun_), + mlc_is_a(A2, xtd::abstract::fun_expr_) >, + xtd::ERROR::ARG2_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, + + public xtd::case_< xtd::tag::meta_2ary_fun_operator, mlc::valist_<E, A1, A2> >::ret {}; @@ -265,7 +318,30 @@ public: template <typename A1, typename A2, typename A3> - struct case_ : public xtd::case_< xtd::tag::meta_3ary_fun_operator, + struct case_ + + : private mlc::assert_< mlc_is_not_a(A1, xtd::abstract::plain_fun_), + xtd::ERROR::ARG1_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc::implies_< mlc_is_a(A1, xtd::abstract::meta_fun_), + mlc_is_a(A1, xtd::abstract::fun_expr_) >, + xtd::ERROR::ARG1_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, + + private mlc::assert_< mlc_is_not_a(A2, xtd::abstract::plain_fun_), + xtd::ERROR::ARG2_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc::implies_< mlc_is_a(A2, xtd::abstract::meta_fun_), + mlc_is_a(A2, xtd::abstract::fun_expr_) >, + xtd::ERROR::ARG2_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, + + private mlc::assert_< mlc_is_not_a(A3, xtd::abstract::plain_fun_), + xtd::ERROR::ARG3_SHOULD_NOT_BE_A_PLAIN_FUN >, + + private mlc::assert_< mlc::implies_< mlc_is_a(A3, xtd::abstract::meta_fun_), + mlc_is_a(A3, xtd::abstract::fun_expr_) >, + xtd::ERROR::ARG3_SHOULD_NOT_BE_A_META_NON_EXPR_FUN >, + + public xtd::case_< xtd::tag::meta_3ary_fun_operator, mlc::valist_<E, A1, A2, A3> >::ret {}; Index: xtd/arg.hh --- xtd/arg.hh (revision 439) +++ xtd/arg.hh (working copy) @@ -36,16 +36,10 @@ - -# define xtd_nargs(F) xtd::nargs_<F>::ret - - - namespace xtd { - namespace internal { Index: tests/id.cc --- tests/id.cc (revision 439) +++ tests/id.cc (working copy) @@ -37,7 +37,9 @@ xtd::plain_id_<float> id_float; std::cout << id_float(5.1f) << std::endl; + // xfail tests: + // xtd::id(id_int); + // xtd::id(xtd::id); } - } Index: tests/bind.cc --- tests/bind.cc (revision 0) +++ tests/bind.cc (revision 0) @@ -0,0 +1,25 @@ +#include <iostream> + +#include <xtd/math.hh> + + +int main() +{ + using xtd::_1; + using xtd::_2; + using xtd::lit; + + (_1 + _2)(_1, _1); + + (_1 + _2)(_1, lit(1.f)); + + (_1 + _2).bind_2(1.f); + + std::cout << (_1 + _2)(5., 1.) << std::endl; + +// std::cout << (_1 + _2)(_1, 1.)(5.) << std::endl; + + // autre probl�me : + // std::cout << (_1 + 1)(5.f) << std::endl; + +} Index: tests/Makefile.am --- tests/Makefile.am (revision 439) +++ tests/Makefile.am (working copy) @@ -9,11 +9,15 @@ check_PROGRAMS = \ id \ + bind \ cast \ - cos + cos \ + lit id_SOURCES = id.cc +bind_SOURCES = bind.cc cast_SOURCES = cast.cc cos_SOURCES = cos.cc +lit_SOURCES = lit.cc TESTS = $(check_PROGRAMS) Index: tests/lit.cc --- tests/lit.cc (revision 0) +++ tests/lit.cc (revision 0) @@ -0,0 +1,25 @@ +#include <iostream> +#include <xtd/literal.hh> + + +int main() +{ + + { + xtd::plain_literal_<double> l(5.1); + } + + { + typedef xtd::meta_literal_<double> F; + F l(5.1); + // xtd_res_0_(F) tmp; + // int warning = tmp; + } + + { + xtd::literal_expr_<double> l(5.1); + } + + + std::cout << mlc_is_a_(xtd::meta_literal_<double>, xtd::abstract::meta_fun_)::eval::value << std::endl; +}

1 0

439: Add mlc::abort_ for use in invalid code blocks.
by Thierry Geraud 24 Mar '06

24 Mar '06

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> Add mlc::abort_ for use in invalid code blocks. * mlc/abort.hh: New. * mlc/TODO: Update. TODO | 32 +++++++++++++++++- abort.hh | 109 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 140 insertions(+), 1 deletion(-) Index: mlc/TODO --- mlc/TODO (revision 438) +++ mlc/TODO (working copy) @@ -19,6 +19,11 @@ not define mlc::uint_; etc. +* addition + +mlc_eval (such as mlc_bool and mlc_value) + + * renaming ** cmp.hh @@ -34,4 +39,29 @@ ** mlc_is_a -It uses wrap_; though, is it really useful? +It uses wrap_; though, is it really useful? the answer seems to be yes. +The code below: + +template <typename T> +struct ok : public something< mlc_is_a(T, int) > +{ +}; + +works well and we do not have to write mlc_is_a_ with the '_' at the end +so that's better. yet is it a direct consequence of the wrapping? + +** boolean and bexpr + +the last part of the disambiguation between boolean and bexpr is to +remove the inheritance between true_ (resp. false_) and bexpr. + +that should lead to: +*** new types +true_expr_ and false_expr_ +*** update +concrete bexprs should not be related to true_ and false_ +static checks should change +*** remove +eval in true_ and false_ + + Index: mlc/abort.hh --- mlc/abort.hh (revision 0) +++ mlc/abort.hh (revision 0) @@ -0,0 +1,109 @@ +// 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_ABORT_HH +# define METALIC_ABORT_HH + +# include <mlc/bexpr.hh> +# include <mlc/assert.hh> +# include <mlc/cmp.hh> +# include <mlc/is_a.hh> + + + +namespace mlc +{ + + namespace ERROR + { + struct FIRST_PARAMETER_OF_mlc_abort_SHOULD_NOT_BE_an_abstract_bexpr; + + } // end of namespace mlc::ERROR + + + namespace internal + { + + /*! \class mlc::always_false_<T> + ** + ** FIXME: doc + ** + ** \see mlc::abort_<T, err> + ** + */ + + template <typename T> + struct always_false_ + + : public bexpr_is_<false> + { + protected: + always_false_() {} + }; + + } // end of mlc::internal + + + + /*! \class mlc::abort_<T, err> + ** + ** FIXME: doc + ** + ** T is important here; since there is an unknown type at compile-time + ** the parsing can run through a routine that owns an abort_ instruction. + ** + ** If there were no free type like this, the routine produces an error + ** at compile-time (actually there is an abort!) even if this routine + ** is not explicitly called in the code. + ** + ** \note \a T can be any type... except a bexpr so that we can + ** detect that the user has used abort_ instead of assert_. + ** + ** \see assert_<bexpr, err> + ** + */ + + template <typename T, typename err = no_error_message> + struct abort_ : + +// private assert_< not_<mlc_is_a(T, abstract::bexpr)>, +// mlc::ERROR::FIRST_PARAMETER_OF_mlc_abort_SHOULD_NOT_BE_an_abstract_bexpr >, + + public internal::always_false_<T> + { + protected: + abort_() {} + }; + + + + + +} // end of namespace mlc + + +#endif // ! METALIC_ABORT_HH

1 0