luabind/operator.hpp

   1 // Copyright (c) 2004 Daniel Wallin and Arvid Norberg
   2
   3 // Permission is hereby granted, free of charge, to any person obtaining a
   4 // copy of this software and associated documentation files (the "Software"),
   5 // to deal in the Software without restriction, including without limitation
   6 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   7 // and/or sell copies of the Software, and to permit persons to whom the
   8 // Software is furnished to do so, subject to the following conditions:
   9
  10 // The above copyright notice and this permission notice shall be included
  11 // in all copies or substantial portions of the Software.
  12
  13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
  14 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  15 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
  17 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  18 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
  21 // OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23 #ifndef OPERATOR_040729_HPP
  24 #define OPERATOR_040729_HPP
  25
  26 #include <boost/mpl/apply_if.hpp>
  27 #include <boost/mpl/identity.hpp>
  28 #include <boost/type_traits/is_same.hpp>
  29 #include <luabind/detail/other.hpp>
  30 #include <luabind/raw_policy.hpp>
  31
  32 namespace luabind { namespace detail {
  33
  34     template<class W, class T> struct unwrap_parameter_type;
  35     template<class Derived> struct operator_ {};
  36
  37     struct operator_void_return {};
  38
  39 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
  40     template<class T>
  41     inline T const& operator,(T const& x, operator_void_return)
  42     {
  43         return x;
  44     }
  45 #endif
  46
  47 }} // namespace luabind
  48
  49 namespace luabind { namespace operators {
  50
  51    #define BOOST_PP_ITERATION_PARAMS_1 (3, \
  52        (0, LUABIND_MAX_ARITY, <luabind/detail/call_operator_iterate.hpp>))
  53    #include BOOST_PP_ITERATE()
  54
  55 }} // namespace luabind::operators
  56
  57 #include <boost/preprocessor/iteration/local.hpp>
  58
  59 namespace luabind {
  60
  61     template<class Derived>
  62     struct self_base
  63     {
  64         operators::call_operator0<Derived> operator()() const
  65         {
  66             return 0;
  67         }
  68
  69 #define BOOST_PP_LOCAL_MACRO(n) \
  70         template<BOOST_PP_ENUM_PARAMS(n, class A)> \
  71         BOOST_PP_CAT(operators::call_operator, n)< \
  72             Derived \
  73             BOOST_PP_ENUM_TRAILING_PARAMS(n, A) \
  74         >\
  75         operator()( \
  76             BOOST_PP_ENUM_BINARY_PARAMS(n, A, const& BOOST_PP_INTERCEPT) \
  77         ) const \
  78         { \
  79             return 0; \
  80         }
  81
  82 #define BOOST_PP_LOCAL_LIMITS (1, LUABIND_MAX_ARITY)
  83 #include BOOST_PP_LOCAL_ITERATE()
  84
  85     };
  86
  87     struct self_type : self_base<self_type>
  88     {
  89     };
  90
  91     struct const_self_type : self_base<const_self_type>
  92     {
  93     };
  94
  95 namespace detail {
  96
  97     template<class W, class T>
  98     struct unwrap_parameter_type
  99     {
 100         typedef typename boost::mpl::apply_if<
 101             boost::is_same<T, self_type>
 102           , boost::mpl::identity<W&>
 103           , boost::mpl::apply_if<
 104                 boost::is_same<T, const_self_type>
 105               , boost::mpl::identity<W const&>
 106               , unwrap_other<T>
 107             >
 108         >::type type;
 109     };
 110
 111     template<class Derived, class A, class B>
 112     struct binary_operator
 113         : operator_<binary_operator<Derived, A, B> >
 114     {
 115         binary_operator(int) {}
 116
 117         template<class T, class Policies>
 118         struct apply
 119         {
 120             typedef typename unwrap_parameter_type<T, A>::type arg0;
 121             typedef typename unwrap_parameter_type<T, B>::type arg1;
 122
 123             static void execute(lua_State* L, arg0 _0, arg1 _1)
 124             {
 125                 Derived::template apply<arg0, arg1, Policies>::execute(
 126                     L, _0, _1);
 127             }
 128         };
 129
 130         static char const* name()
 131         {
 132             return Derived::name();
 133         }
 134     };
 135
 136     template<class Derived, class A>
 137     struct unary_operator
 138         : operator_<unary_operator<Derived, A> >
 139     {
 140         unary_operator(int) {}
 141
 142         template<class T, class Policies>
 143         struct apply
 144         {
 145             typedef typename unwrap_parameter_type<T, A>::type arg0;
 146
 147             static void execute(lua_State* L, arg0 _0)
 148             {
 149                 Derived::template apply<arg0, Policies>::execute(L, _0);
 150             }
 151         };
 152
 153         static char const* name()
 154         {
 155             return Derived::name();
 156         }
 157     };
 158
 159     template<class Policies>
 160     inline void operator_result(lua_State* L, operator_void_return, Policies*)
 161     {
 162     }
 163
 164     template<class T, class Policies>
 165     inline void operator_result(lua_State* L, T const& x, Policies*)
 166     {
 167         typedef typename find_conversion_policy<
 168             0
 169           , Policies
 170         >::type cv_policy;
 171
 172         typename cv_policy::template generate_converter<
 173             T
 174           , cpp_to_lua
 175         >::type cv;
 176
 177         cv.apply(L, x);
 178     }
 179
 180 }} // namespace detail::luabind
 181
 182 namespace luabind {
 183
 184 #define LUABIND_BINARY_OPERATOR(name_, op) \
 185     namespace operators { \
 186 \
 187         struct name_ \
 188         { \
 189             template<class T0, class T1, class Policies> \
 190             struct apply \
 191             { \
 192                 static void execute(lua_State* L, T0 _0, T1 _1) \
 193                 { \
 194                     detail::operator_result(L, _0 op _1, (Policies*)0); \
 195                 } \
 196             }; \
 197 \
 198             static char const* name() \
 199             { \
 200                 return "__" # name_; \
 201             } \
 202         }; \
 203 \
 204     } \
 205     \
 206     template<class T, class U> \
 207     detail::binary_operator< \
 208         operators::name_ \
 209       , U \
 210       , T \
 211     > \
 212     inline operator op(self_base<U>, T const&) \
 213     { \
 214         return 0; \
 215     } \
 216     \
 217     template<class T, class U> \
 218     detail::binary_operator< \
 219         operators::name_ \
 220       , T \
 221       , U \
 222     > \
 223     inline operator op(T const&, self_base<U>) \
 224     { \
 225         return 0; \
 226     } \
 227     \
 228     detail::binary_operator< \
 229         operators::name_ \
 230       , self_type \
 231       , self_type \
 232     > \
 233     inline operator op(self_type, self_type) \
 234     { \
 235         return 0; \
 236     } \
 237     \
 238     detail::binary_operator< \
 239         operators::name_ \
 240       , self_type \
 241       , const_self_type \
 242     > \
 243     inline operator op(self_type, const_self_type) \
 244     { \
 245         return 0; \
 246     } \
 247     \
 248     detail::binary_operator< \
 249         operators::name_ \
 250       , const_self_type \
 251       , self_type \
 252     > \
 253     inline operator op(const_self_type, self_type) \
 254     { \
 255         return 0; \
 256     } \
 257     \
 258     detail::binary_operator< \
 259         operators::name_ \
 260       , const_self_type \
 261       , const_self_type \
 262     > \
 263     inline operator op(const_self_type, const_self_type) \
 264     { \
 265         return 0; \
 266     }
 267
 268     LUABIND_BINARY_OPERATOR(add, +)
 269     LUABIND_BINARY_OPERATOR(sub, -)
 270     LUABIND_BINARY_OPERATOR(mul, *)
 271     LUABIND_BINARY_OPERATOR(div, /)
 272     LUABIND_BINARY_OPERATOR(pow, ^)
 273     LUABIND_BINARY_OPERATOR(lt, <)
 274     LUABIND_BINARY_OPERATOR(le, <=)
 275     LUABIND_BINARY_OPERATOR(eq, ==)
 276
 277 #undef LUABIND_UNARY_OPERATOR
 278
 279 #define LUABIND_UNARY_OPERATOR(name_, op, fn) \
 280     namespace operators { \
 281 \
 282         struct name_ \
 283         { \
 284             template<class T, class Policies> \
 285             struct apply \
 286             { \
 287                 static void execute(lua_State* L, T x) \
 288                 { \
 289                     detail::operator_result(L, op(x), (Policies*)0); \
 290                 } \
 291             }; \
 292 \
 293             static char const* name() \
 294             { \
 295                 return "__" # name_; \
 296             } \
 297         }; \
 298 \
 299     } \
 300     \
 301     template<class T> \
 302     detail::unary_operator< \
 303         operators::name_ \
 304       , T \
 305     > \
 306     inline fn(self_base<T>) \
 307     { \
 308         return 0; \
 309     }
 310
 311     template<class T>
 312     T const& tostring_operator(T const& x)
 313     {
 314         return x;
 315     };
 316
 317     LUABIND_UNARY_OPERATOR(tostring, tostring_operator, tostring)
 318     LUABIND_UNARY_OPERATOR(unm, -, operator-)
 319
 320 #undef LUABIND_BINARY_OPERATOR
 321
 322     namespace {
 323
 324         LUABIND_ANONYMOUS_FIX self_type self;
 325         LUABIND_ANONYMOUS_FIX const_self_type const_self;
 326
 327     } // namespace unnamed
 328
 329 } // namespace luabind
 330
 331 #endif // OPERATOR_040729_HPP
 332