test/test_implicit_cast.cpp

   1 #include "test.hpp"
   2 #include <luabind/luabind.hpp>
   3
   4 namespace {
   5
   6     struct A : counted_type<A>
   7     { virtual ~A() {} };
   8
   9     struct B : A, counted_type<B>
  10     {};
  11
  12     struct test_implicit : counted_type<test_implicit>
  13     {
  14         char const* f(A*) { return "f(A*)"; }
  15         char const* f(B*) { return "f(B*)"; }
  16     };
  17
  18     struct char_pointer_convertible
  19         : counted_type<char_pointer_convertible>
  20     {
  21         operator const char*() const { return "foo!"; }
  22     };
  23
  24     void func(const char_pointer_convertible& f)
  25     {
  26     }
  27
  28 } // anonymous namespace
  29
  30 void test_implicit_cast()
  31 {
  32     COUNTER_GUARD(A);
  33     COUNTER_GUARD(B);
  34     COUNTER_GUARD(test_implicit);
  35     COUNTER_GUARD(char_pointer_convertible);
  36
  37     lua_state L;
  38
  39     using namespace luabind;
  40
  41     typedef char const*(test_implicit::*f1)(A*);
  42     typedef char const*(test_implicit::*f2)(B*);
  43
  44     module(L)
  45     [
  46         class_<A>("A")
  47             .def(constructor<>()),
  48
  49         class_<B, A>("B")
  50             .def(constructor<>()),
  51
  52         class_<test_implicit>("test")
  53             .def(constructor<>())
  54             .def("f", (f1)&test_implicit::f)
  55             .def("f", (f2)&test_implicit::f),
  56
  57         class_<char_pointer_convertible>("char_ptr")
  58             .def(constructor<>()),
  59
  60         def("func", &func)
  61     ];
  62
  63     DOSTRING(L, "a = A()");
  64     DOSTRING(L, "b = B()");
  65     DOSTRING(L, "t = test()");
  66
  67     DOSTRING(L, "assert(t:f(a) == 'f(A*)')");
  68     DOSTRING(L, "assert(t:f(b) == 'f(B*)')");
  69
  70     DOSTRING(L,
  71         "a = char_ptr()\n"
  72         "func(a)");
  73 }
  74