• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Classes
  • Files
  • File List

binary.hh

00001 // Copyright (C) 2007, 2008, 2009 EPITA Research and Development Laboratory (LRDE)
00002 //
00003 // This file is part of Olena.
00004 //
00005 // Olena is free software: you can redistribute it and/or modify it under
00006 // the terms of the GNU General Public License as published by the Free
00007 // Software Foundation, version 2 of the License.
00008 //
00009 // Olena is distributed in the hope that it will be useful,
00010 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00011 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012 // General Public License for more details.
00013 //
00014 // You should have received a copy of the GNU General Public License
00015 // along with Olena.  If not, see <http://www.gnu.org/licenses/>.
00016 //
00017 // As a special exception, you may use this file as part of a free
00018 // software project without restriction.  Specifically, if other files
00019 // instantiate templates or use macros or inline functions from this
00020 // file, or you compile this file and link it with other files to produce
00021 // an executable, this file does not by itself cause the resulting
00022 // executable to be covered by the GNU General Public License.  This
00023 // exception does not however invalidate any other reasons why the
00024 // executable file might be covered by the GNU General Public License.
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       // Forward declaration
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       } // end of namespace mln::fun::spe::impl
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     } // end of namespace mln::fun::spe
00140 
00141   } // end of namespace mln::fun
00142 
00143 } // end of namespace mln
00144 
00145 #endif // ! MLN_FUN_SPE_BINARY_HH

Generated on Mon Jan 30 2012 17:35:40 for Milena (Olena) by  doxygen 1.7.1