00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef MLN_FUN_SPE_BINARY_HH
00027 # define MLN_FUN_SPE_BINARY_HH
00028
00029 # include <mln/core/concept/function.hh>
00030 # include <mln/trait/next/solve.hh>
00031 # include <mln/trait/functions.hh>
00032
00034
00035 namespace mln
00036 {
00037
00038 namespace fun
00039 {
00040
00041 namespace spe
00042 {
00043
00044
00045 template <typename Fun, typename T1, typename T2>
00046 struct binary;
00047
00048 namespace impl
00049 {
00050
00051 template <bool has_param, typename Fun, typename T1, typename T2>
00052 struct binary_impl;
00053
00054 template <typename Fun, typename T1, typename T2>
00055 struct binary_impl<false, Fun, T1, T2>
00056 : mln::Function_v2v< binary<Fun, T1, T2> >
00057 {
00058 typedef Fun flag;
00059 typedef mln_trait_nbinary(flag, T1, T2) def;
00060
00061 typedef typename def::argument1 argument1;
00062 typedef typename def::argument2 argument2;
00063 typedef typename def::result result;
00064
00065 result operator () (const argument1& a, const argument2& b) const
00066 {
00067 return def::read(a, b);
00068 }
00069
00070
00071 template <typename U>
00072 void init(const U& value)
00073 {
00074 (void) value;
00075 }
00076
00077 };
00078
00079 template <typename Fun, typename T1, typename T2>
00080 struct binary_impl<true, Fun, T1, T2>
00081 : mln::Function_v2v< binary<Fun, T1, T2> >
00082 {
00083 typedef Fun flag;
00084 typedef mln_trait_nbinary(flag, T1, T2) def;
00085
00086 typedef typename def::argument1 argument1;
00087 typedef typename def::argument2 argument2;
00088 typedef typename def::result result;
00089
00090 typedef mln_trait_fun_param(def) param;
00091 typedef mln_trait_fun_storage(def) storage;
00092
00093 result operator () (const argument1& a, const argument2& b) const
00094 {
00095 return def::read(state_, a, b);
00096 }
00097
00098 template <typename U>
00099 void init(const U& value)
00100 {
00101 state_ = mln::trait::function::internal::introspect::has_storage_t<def, void>::compute(value);
00102 }
00103
00104 stored<storage>& state()
00105 {
00106 return state_;
00107 }
00108
00109 const stored<storage>& state() const
00110 {
00111 return state_;
00112 }
00113
00114 protected:
00115 mln::fun::stored<storage> state_;
00116 };
00117
00118 }
00119
00120 template <typename Fun, typename T1, typename T2>
00121 struct binary
00122 : impl::binary_impl<mln_trait_fun_is_parametrable_(Fun)::value, Fun, T1, T2>
00123 {
00124 typedef impl::binary_impl<mln_trait_fun_is_parametrable_(Fun)::value, Fun, T1, T2> super;
00125
00126 binary()
00127 {
00128 }
00129
00130 template <typename U>
00131 binary(const U& param)
00132 {
00133 this->super::init(param);
00134 }
00135
00136 using super::operator();
00137 };
00138
00139 }
00140
00141 }
00142
00143 }
00144
00145 #endif // ! MLN_FUN_SPE_BINARY_HH