examples/intrusive_ptr/intrusive_ptr.cpp

   1 #include <iostream>
   2
   3 extern "C"
   4 {
   5         #include "lua.h"
   6         #include "lauxlib.h"
   7         #include "lualib.h"
   8 }
   9
  10 bool dostring(lua_State* L, const char* str)
  11 {
  12         if (luaL_loadbuffer(L, str, std::strlen(str), str) || lua_pcall(L, 0, 0, 0))
  13         {
  14                 const char* a = lua_tostring(L, -1);
  15                 std::cout << a << "\n";
  16                 lua_pop(L, 1);
  17                 return true;
  18         }
  19         return false;
  20 }
  21
  22 #include <luabind/luabind.hpp>
  23 #include <boost/intrusive_ptr.hpp>
  24
  25 namespace luabind
  26 {
  27         namespace converters
  28         {
  29                 // tell luabind that there is a converter for boost::intrusive_ptr<T>
  30                 template<class T>
  31                 yes_t is_user_defined(by_value<boost::intrusive_ptr<T> >);
  32
  33                 template<class T>
  34                 yes_t is_user_defined(by_const_reference<boost::intrusive_ptr<T> >);
  35
  36                 // function used to destruct the object in lua
  37                 template<class T>
  38                 struct decrement_ref_count
  39                 {
  40                         static void apply(void* ptr)
  41                         {
  42                                 T* p = static_cast<T*>(ptr);
  43                                 intrusive_ptr_release(p);
  44                         }
  45                 };
  46
  47                 template<class T>
  48                 void convert_cpp_to_lua(lua_State* L, const boost::intrusive_ptr<T>& ptr)
  49                 {
  50                         if (!ptr)
  51                         {
  52                                 lua_pushnil(L);
  53                                 return;
  54                         }
  55
  56                         T* raw_ptr = ptr.get();
  57                         // add reference to object, this will be released when the object is collected
  58                         intrusive_ptr_add_ref(raw_ptr);
  59
  60                         detail::class_registry* registry = luabind::detail::class_registry::get_registry(L);
  61                         detail::class_rep* crep = registry->find_class(LUABIND_TYPEID(T));
  62
  63                         assert(crep != 0 && "You are trying to convert an unregistered type");
  64
  65                         // create the struct to hold the object
  66                         void* obj = lua_newuserdata(L, sizeof(detail::object_rep));
  67                         // we send 0 as destructor since we know it will never be called
  68                         new(obj) luabind::detail::object_rep(raw_ptr, crep, detail::object_rep::owner, decrement_ref_count<T>::apply);
  69
  70                         // set the meta table
  71                         detail::getref(L, crep->metatable_ref());
  72                         lua_setmetatable(L, -2);
  73                 }
  74
  75                 template<class T>
  76                 boost::intrusive_ptr<T>
  77                 convert_lua_to_cpp(lua_State* L, by_const_reference<boost::intrusive_ptr<T> >, int index)
  78                 {
  79                         typename detail::default_policy::template generate_converter<T*, detail::lua_to_cpp>::type converter;
  80                         T* ptr = converter.apply(L, LUABIND_DECORATE_TYPE(T*), index);
  81                         return boost::intrusive_ptr<T>(ptr);
  82                 }
  83
  84                 template<class T>
  85                 boost::intrusive_ptr<T> convert_lua_to_cpp(lua_State* L, by_value<boost::intrusive_ptr<T> >, int index)
  86                 {
  87                         return convert_lua_to_cpp(L, by_const_reference<boost::intrusive_ptr<T> >(), index);
  88                 }
  89
  90                 template<class T>
  91                 int match_lua_to_cpp(lua_State* L, by_value<boost::intrusive_ptr<T> >, int index)
  92                 {
  93                         typedef typename detail::default_policy::template generate_converter<T*, detail::lua_to_cpp>::type converter_t;
  94                         return converter_t::match(L, LUABIND_DECORATE_TYPE(T*), index);
  95                 }
  96
  97                 template<class T>
  98                 int match_lua_to_cpp(lua_State* L, by_const_reference<boost::intrusive_ptr<T> >, int index)
  99                 {
 100                         typedef typename detail::default_policy::template generate_converter<T*, detail::lua_to_cpp>::type converter_t;
 101                         return converter_t::match(L, LUABIND_DECORATE_TYPE(T*), index);
 102                 }
 103
 104         }
 105 }
 106
 107 struct A
 108 {
 109         A()
 110         : cnt(0)
 111         {}
 112
 113         ~A() { std::cout << "free memory\n"; }
 114
 115         int cnt;
 116 };
 117
 118 void intrusive_ptr_add_ref(A* ptr)
 119 {
 120         ++ptr->cnt;
 121         std::cout << "add ref\n";
 122 }
 123
 124 void intrusive_ptr_release(A* ptr)
 125 {
 126         --ptr->cnt;
 127         std::cout << "release\n";
 128         if (ptr->cnt == 0) delete ptr;
 129 }
 130
 131 void f(boost::intrusive_ptr<A> ptr)
 132 {
 133         std::cout << "count: " << ptr->cnt << "\n";
 134 }
 135
 136 boost::intrusive_ptr<A> factory()
 137 {
 138         return boost::intrusive_ptr<A>(new A());
 139 }
 140
 141 int main()
 142 {
 143         lua_State* L = lua_open();
 144         lua_baselibopen(L);
 145
 146         luabind::open(L);
 147
 148         using namespace luabind;
 149
 150         module(L)
 151         [
 152                 class_<A>("A")
 153                         .def_readonly("cnt", &A::cnt),
 154
 155                 def("factory", &factory),
 156                 def("f", &f)
 157         ];
 158
 159         dostring(L, "a = factory()");
 160         dostring(L, "print('lua count: ' .. a.cnt)");
 161         dostring(L, "f(a)");
 162
 163         lua_close(L);
 164         return 0;
 165 }
 166