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/eval_if.hpp>
  27 #include <boost/mpl/identity.hpp>
  28 #include <boost/mpl/apply_wrap.hpp>
  29 #ifndef LUABIND_CPP0x
  30 #include <boost/preprocessor/repetition/enum_trailing.hpp>
  31 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
  32 #endif
  33 #include <boost/type_traits/is_same.hpp>
  34 #include <luabind/detail/other.hpp>
  35 #include <luabind/raw_policy.hpp>
  36
  37 #if defined(__GNUC__) && __GNUC__ < 3
  38 # define LUABIND_NO_STRINGSTREAM
  39 #else
  40 # if defined(BOOST_NO_STRINGSTREAM)
  41 #  define LUABIND_NO_STRINGSTREAM
  42 # endif
  43 #endif
  44
  45 #ifdef LUABIND_NO_STRINGSTREAM
  46 #include <strstream>
  47 #else
  48 #include <sstream>
  49 #endif
  50
  51 namespace luabind { namespace detail {
  52
  53     template<class W, class T> struct unwrap_parameter_type;
  54     template<class Derived> struct operator_ {};
  55
  56     struct operator_void_return {};
  57
  58 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
  59     template<class T>
  60     inline T const& operator,(T const& x, operator_void_return)
  61     {
  62         return x;
  63     }
  64 #endif
  65
  66 }} // namespace luabind
  67
  68 namespace luabind { namespace operators {
  69
  70 # ifdef LUABIND_CPP0x
  71
  72 template <class Self, class... Args>
  73 struct call_operator
  74   : detail::operator_<call_operator>
  75 {
  76     call_operator(int)
  77     {}
  78
  79     template <class T, class Policies>
  80     struct apply
  81     {
  82         static void execute(
  83             lua_State* L
  84           , typename detail::unwrap_parameter_type<T, Self>::type self
  85           , detail::unwrap_parameter_type<T, Args>::type args...
  86         )
  87         {
  88             using namespace detail;
  89             operator_result(
  90                 L
  91               , (self(args...), detail::operator_void_return())
  92               , (Policies*)0
  93             );
  94         }
  95     };
  96
  97     static char const* name() { return "__call"; }
  98 };
  99
 100 # else // LUABIND_CPP_0x
 101    #define BOOST_PP_ITERATION_PARAMS_1 (3, \
 102        (0, LUABIND_MAX_ARITY, <luabind/detail/call_operator_iterate.hpp>))
 103    #include BOOST_PP_ITERATE()
 104 # endif // LUABIND_CPP_0x
 105
 106 }} // namespace luabind::operators
 107
 108 #ifndef LUABIND_CPP0x
 109 # include <boost/preprocessor/iteration/local.hpp>
 110 #endif
 111
 112 namespace luabind {
 113
 114     template<class Derived>
 115     struct self_base
 116     {
 117 # ifdef LUABIND_CPP0x
 118
 119         template <class... Args>
 120         operators::call_operator<Derived, Args...> operator()(Args const&...) const
 121         {
 122             return 0;
 123         }
 124
 125 # else // LUABIND_CPP0x
 126
 127         operators::call_operator0<Derived> operator()() const
 128         {
 129             return 0;
 130         }
 131
 132 #define BOOST_PP_LOCAL_MACRO(n) \
 133         template<BOOST_PP_ENUM_PARAMS(n, class A)> \
 134         BOOST_PP_CAT(operators::call_operator, n)< \
 135             Derived \
 136             BOOST_PP_ENUM_TRAILING_PARAMS(n, A) \
 137         >\
 138         operator()( \
 139             BOOST_PP_ENUM_BINARY_PARAMS(n, A, const& BOOST_PP_INTERCEPT) \
 140         ) const \
 141         { \
 142             return 0; \
 143         }
 144
 145 #define BOOST_PP_LOCAL_LIMITS (1, LUABIND_MAX_ARITY)
 146 #include BOOST_PP_LOCAL_ITERATE()
 147
 148 # endif // LUABIND_CPP0x
 149
 150     };
 151
 152     struct self_type : self_base<self_type>
 153     {
 154     };
 155
 156     struct const_self_type : self_base<const_self_type>
 157     {
 158     };
 159
 160 namespace detail {
 161
 162     template<class W, class T>
 163     struct unwrap_parameter_type
 164     {
 165         typedef typename boost::mpl::eval_if<
 166             boost::is_same<T, self_type>
 167           , boost::mpl::identity<W&>
 168           , boost::mpl::eval_if<
 169                 boost::is_same<T, const_self_type>
 170               , boost::mpl::identity<W const&>
 171               , unwrap_other<T>
 172             >
 173         >::type type;
 174     };
 175
 176     template<class Derived, class A, class B>
 177     struct binary_operator
 178         : operator_<binary_operator<Derived, A, B> >
 179     {
 180         binary_operator(int) {}
 181
 182         template<class T, class Policies>
 183         struct apply
 184         {
 185             typedef typename unwrap_parameter_type<T, A>::type arg0;
 186             typedef typename unwrap_parameter_type<T, B>::type arg1;
 187
 188             static void execute(lua_State* L, arg0 _0, arg1 _1)
 189             {
 190                 Derived::template apply<arg0, arg1, Policies>::execute(
 191                     L, _0, _1);
 192             }
 193         };
 194
 195         static char const* name()
 196         {
 197             return Derived::name();
 198         }
 199     };
 200
 201     template<class Derived, class A>
 202     struct unary_operator
 203         : operator_<unary_operator<Derived, A> >
 204     {
 205         unary_operator(int) {}
 206
 207         template<class T, class Policies>
 208         struct apply
 209         {
 210             typedef typename unwrap_parameter_type<T, A>::type arg0;
 211
 212             static void execute(lua_State* L, arg0 _0)
 213             {
 214                 Derived::template apply<arg0, Policies>::execute(L, _0);
 215             }
 216         };
 217
 218         static char const* name()
 219         {
 220             return Derived::name();
 221         }
 222     };
 223
 224     template<class Policies>
 225     inline void operator_result(lua_State* L, operator_void_return, Policies*)
 226     {
 227     }
 228
 229     namespace mpl = boost::mpl;
 230
 231     template<class T, class Policies>
 232     inline void operator_result(lua_State* L, T const& x, Policies*)
 233     {
 234         typedef typename find_conversion_policy<
 235             0
 236           , Policies
 237         >::type cv_policy;
 238
 239         typename mpl::apply_wrap2<cv_policy,T,cpp_to_lua>::type cv;
 240
 241         cv.apply(L, x);
 242     }
 243
 244 }} // namespace detail::luabind
 245
 246 namespace luabind {
 247
 248 #define LUABIND_BINARY_OPERATOR(name_, op) \
 249     namespace operators { \
 250 \
 251         struct name_ \
 252         { \
 253             template<class T0, class T1, class Policies> \
 254             struct apply \
 255             { \
 256                 static void execute(lua_State* L, T0 _0, T1 _1) \
 257                 { \
 258                     detail::operator_result(L, _0 op _1, (Policies*)0); \
 259                 } \
 260             }; \
 261 \
 262             static char const* name() \
 263             { \
 264                 return "__" # name_; \
 265             } \
 266         }; \
 267 \
 268     } \
 269     \
 270     template<class T, class U> \
 271     detail::binary_operator< \
 272         operators::name_ \
 273       , U \
 274       , T \
 275     > \
 276     inline operator op(self_base<U>, T const&) \
 277     { \
 278         return 0; \
 279     } \
 280     \
 281     template<class T, class U> \
 282     detail::binary_operator< \
 283         operators::name_ \
 284       , T \
 285       , U \
 286     > \
 287     inline operator op(T const&, self_base<U>) \
 288     { \
 289         return 0; \
 290     } \
 291     \
 292     detail::binary_operator< \
 293         operators::name_ \
 294       , self_type \
 295       , self_type \
 296     > \
 297     inline operator op(self_type, self_type) \
 298     { \
 299         return 0; \
 300     } \
 301     \
 302     detail::binary_operator< \
 303         operators::name_ \
 304       , self_type \
 305       , const_self_type \
 306     > \
 307     inline operator op(self_type, const_self_type) \
 308     { \
 309         return 0; \
 310     } \
 311     \
 312     detail::binary_operator< \
 313         operators::name_ \
 314       , const_self_type \
 315       , self_type \
 316     > \
 317     inline operator op(const_self_type, self_type) \
 318     { \
 319         return 0; \
 320     } \
 321     \
 322     detail::binary_operator< \
 323         operators::name_ \
 324       , const_self_type \
 325       , const_self_type \
 326     > \
 327     inline operator op(const_self_type, const_self_type) \
 328     { \
 329         return 0; \
 330     }
 331
 332     LUABIND_BINARY_OPERATOR(add, +)
 333     LUABIND_BINARY_OPERATOR(sub, -)
 334     LUABIND_BINARY_OPERATOR(mul, *)
 335     LUABIND_BINARY_OPERATOR(div, /)
 336     LUABIND_BINARY_OPERATOR(pow, ^)
 337     LUABIND_BINARY_OPERATOR(lt, <)
 338     LUABIND_BINARY_OPERATOR(le, <=)
 339     LUABIND_BINARY_OPERATOR(eq, ==)
 340
 341 #undef LUABIND_UNARY_OPERATOR
 342
 343 #define LUABIND_UNARY_OPERATOR(name_, op, fn) \
 344     namespace operators { \
 345 \
 346         struct name_ \
 347         { \
 348             template<class T, class Policies> \
 349             struct apply \
 350             { \
 351                 static void execute(lua_State* L, T x) \
 352                 { \
 353                     detail::operator_result(L, op(x), (Policies*)0); \
 354                 } \
 355             }; \
 356 \
 357             static char const* name() \
 358             { \
 359                 return "__" # name_; \
 360             } \
 361         }; \
 362 \
 363     } \
 364     \
 365     template<class T> \
 366     detail::unary_operator< \
 367         operators::name_ \
 368       , T \
 369     > \
 370     inline fn(self_base<T>) \
 371     { \
 372         return 0; \
 373     }
 374
 375     template<class T>
 376     std::string tostring_operator(T const& x)
 377     {
 378 #ifdef LUABIND_NO_STRINGSTREAM
 379         std::strstream s;
 380         s << x << std::ends;
 381 #else
 382         std::stringstream s;
 383         s << x;
 384 #endif
 385         return s.str();
 386     }
 387
 388     LUABIND_UNARY_OPERATOR(tostring, tostring_operator, tostring)
 389     LUABIND_UNARY_OPERATOR(unm, -, operator-)
 390
 391 #undef LUABIND_BINARY_OPERATOR
 392
 393     namespace {
 394
 395         LUABIND_ANONYMOUS_FIX self_type self;
 396         LUABIND_ANONYMOUS_FIX const_self_type const_self;
 397
 398     } // namespace unnamed
 399
 400 } // namespace luabind
 401
 402 #endif // OPERATOR_040729_HPP
 403