luabind/scope.hpp

   1 // Copyright (c) 2003 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
  24 #ifndef LUABIND_SCOPE_HPP_INCLUDED
  25 #define LUABIND_SCOPE_HPP_INCLUDED
  26
  27 #include <vector>
  28 #include <string>
  29 #include <stack>
  30
  31 #include <luabind/detail/ref.hpp>
  32
  33 namespace luabind
  34 {
  35         namespace detail
  36         {
  37                 struct scoped_sequence;
  38
  39                 struct scoped_object
  40                 {
  41                         scoped_object()
  42                         {
  43                         }
  44
  45                         virtual ~scoped_object() {}
  46
  47                         virtual void commit(lua_State*) = 0;
  48                         virtual scoped_object* clone() = 0;
  49
  50                         scoped_sequence operator,(const scoped_object& rhs) const;
  51                 };
  52
  53                 struct scoped_sequence : scoped_object
  54                 {
  55                         scoped_sequence(scoped_object* a, scoped_object* b)
  56                         {
  57 #ifndef NDEBUG
  58                                 m_cloned = false;
  59 #endif
  60                                 this->objects.push_back(a);
  61                                 this->objects.push_back(b);
  62                         }
  63
  64                         scoped_sequence()
  65                         {
  66 #ifndef NDEBUG
  67                                 m_cloned = false;
  68 #endif
  69                         }
  70
  71                         virtual ~scoped_sequence()
  72                         {
  73                                         for (std::vector<scoped_object*>
  74                                                         ::const_iterator i = this->objects.begin()
  75                                                                                                 ; i != this->objects.end()
  76                                                                                                 ; ++i)
  77                                         {
  78                                                 scoped_object* ptr = *i;
  79                                                 delete ptr;
  80                                         }
  81                         }
  82
  83                         scoped_sequence& operator,(const scoped_object& rhs)
  84                         {
  85                                 objects.push_back(const_cast<scoped_object&>(rhs).clone());
  86                                 return *this;
  87                         }
  88
  89                         virtual scoped_object* clone()
  90                         {
  91                                 scoped_sequence* copy = new scoped_sequence();
  92                                 copy->objects.swap(this->objects);
  93
  94                                 assert(!m_cloned && "You cannot register the scoped_object twice");
  95 #ifndef NDEBUG
  96                                 m_cloned = true;
  97 #endif
  98                                 return copy;
  99                         }
 100
 101                         virtual void commit(lua_State* L)
 102                         {
 103                                 assert(!m_cloned && "You cannot register the scoped_object twice");
 104
 105                                 for (std::vector<scoped_object*>
 106                                                         ::const_iterator i = this->objects.begin()
 107                                                                                                 ; i != this->objects.end()
 108                                                                                                 ; ++i)
 109                                 {
 110                                         scoped_object* ptr = *i;
 111                                         ptr->commit(L);
 112                                 }
 113 #ifndef NDEBUG
 114                                 m_cloned = false;
 115 #endif
 116
 117                         }
 118
 119                 private:
 120 #ifndef NDEBUG
 121                         bool m_cloned;
 122 #endif
 123                         mutable std::vector<scoped_object*> objects;
 124
 125                 };
 126
 127                 inline scoped_sequence scoped_object::operator,(const scoped_object& rhs) const
 128                 {
 129                         return scoped_sequence(const_cast<scoped_object*>(this)->clone(), const_cast<scoped_object&>(rhs).clone());
 130                 }
 131
 132         }
 133
 134         struct scope_stack
 135         {
 136                 std::stack<int> scopes;
 137
 138                 static int gc(lua_State* L)
 139                 {
 140                         scope_stack* scopes = static_cast<scope_stack*>(
 141                                 lua_touserdata(L, -1)
 142                         );
 143
 144                         assert(scopes->scopes.size() == 1);
 145
 146                         int top = scopes->scopes.top();
 147                         scopes->scopes.pop();
 148
 149                         detail::unref(L, top);
 150
 151                         scopes->~scope_stack();
 152
 153                         return 0;
 154                 }
 155
 156                 static int top(lua_State* L)
 157                 {
 158                         lua_pushstring(L, "__luabind_scope_stack");
 159                         lua_gettable(L, LUA_REGISTRYINDEX);
 160
 161                         scope_stack* scopes = static_cast<scope_stack*>(
 162                                 lua_touserdata(L, -1)
 163                         );
 164
 165                         lua_pop(L, 1);
 166
 167                         return scopes->scopes.top();
 168                 }
 169
 170                 static void push(lua_State* L)
 171                 {
 172                         lua_pushstring(L, "__luabind_scope_stack");
 173                         lua_gettable(L, LUA_REGISTRYINDEX);
 174
 175                         scope_stack* scopes = static_cast<scope_stack*>(
 176                                 lua_touserdata(L, -1)
 177                         );
 178
 179                         lua_pop(L, 1);
 180
 181                         scopes->scopes.push(detail::ref(L));
 182                 }
 183
 184                 static void pop(lua_State* L)
 185                 {
 186                         lua_pushstring(L, "__luabind_scope_stack");
 187                         lua_gettable(L, LUA_REGISTRYINDEX);
 188
 189                         scope_stack* scopes = static_cast<scope_stack*>(
 190                                 lua_touserdata(L, -1)
 191                         );
 192
 193                         lua_pop(L, 1);
 194
 195                         int n = scopes->scopes.top();
 196                         scopes->scopes.pop();
 197                         detail::unref(L, n);
 198                 }
 199         };
 200
 201         class scope : public detail::scoped_object
 202         {
 203         public:
 204
 205                 static void init(lua_State* L)
 206                 {
 207                         lua_pushstring(L, "__luabind_scope_stack");
 208                         lua_gettable(L, LUA_REGISTRYINDEX);
 209
 210                         scope_stack* scopes = static_cast<scope_stack*>(
 211                                 lua_touserdata(L, -1)
 212                         );
 213
 214                         lua_pop(L, 1);
 215
 216                         if (scopes == 0)
 217                         {
 218                                 scopes = static_cast<scope_stack*>(
 219                                         lua_newuserdata(L, sizeof(scope_stack))
 220                                 );
 221
 222                                 lua_pushstring(L, "__luabind_scope_stack");
 223                                 lua_pushvalue(L, -2);
 224                                 lua_settable(L, LUA_REGISTRYINDEX);
 225
 226                                 new (scopes) scope_stack();
 227
 228                                 lua_pushvalue(L, LUA_GLOBALSINDEX);
 229                                 scopes->scopes.push(detail::ref(L));
 230
 231                                 lua_newtable(L);
 232                                 lua_pushstring(L, "__gc");
 233                                 lua_pushcclosure(L, scope_stack::gc, 0);
 234                                 lua_settable(L, -3);
 235                                 lua_setmetatable(L, -2);
 236
 237                                 lua_pop(L, 1);
 238                         }
 239                 }
 240
 241                 scope(lua_State* L, const char* name)
 242                         : m_state(L)
 243                         , m_name(name)
 244                 {
 245 #ifndef NDEBUG
 246                         m_cloned = false;
 247 #endif
 248                         init(L);
 249                 }
 250
 251                 scope(const char* name)
 252                         : m_state(0)
 253                         , m_name(name)
 254                 {
 255 #ifndef NDEBUG
 256                         m_cloned = false;
 257 #endif
 258                 }
 259
 260                 virtual ~scope()
 261                 {
 262                         for (std::vector<detail::scoped_object*>
 263                                         ::const_iterator i = m_children.begin()
 264                                                                                 ; i != m_children.end()
 265                                                                                 ; ++i)
 266                         {
 267                                 detail::scoped_object* ptr = *i;
 268                                 delete ptr;
 269                         }
 270                 }
 271
 272                 scope& operator[](const detail::scoped_object& x)
 273                 {
 274                         m_children.push_back(const_cast<detail::scoped_object&>(x).clone());
 275
 276                         if (m_state)
 277                         {
 278                                 this->commit(m_state);
 279
 280                                 for (std::vector<detail::scoped_object*>
 281                                                 ::const_iterator i = m_children.begin()
 282                                                                                         ; i != m_children.end()
 283                                                                                         ; ++i)
 284                                 {
 285                                         detail::scoped_object* ptr = *i;
 286                                         delete ptr;
 287                                 }
 288
 289                                 m_children.clear();
 290                         }
 291
 292                         return *this;
 293                 }
 294
 295                 virtual detail::scoped_object* clone()
 296                 {
 297                         assert(!m_cloned && "cannot register the same namespace twice");
 298 #ifndef NDEBUG
 299                         m_cloned = true;
 300 #endif
 301                         std::vector<detail::scoped_object*> tmp;
 302                         tmp.swap(this->m_children);
 303                         scope* copy = new scope(m_name.c_str());
 304                         copy->m_children.swap(tmp);
 305                         return copy;
 306                 }
 307
 308                 virtual void commit(lua_State* L)
 309                 {
 310                         assert(!m_cloned && "cannot register the same namespace twice");
 311 #ifndef NDEBUG
 312                         m_cloned = true;
 313 #endif
 314                         init(L);
 315
 316                         detail::getref(L, scope_stack::top(L)); // get current scope
 317                         lua_pushstring(L, m_name.c_str());
 318                         lua_gettable(L, -2);
 319                         lua_remove(L, -2); // remove scope
 320
 321                         if (lua_isnil(L, -1))
 322                         {
 323                                 lua_pop(L, 1);
 324
 325                                 lua_newtable(L);
 326                                 detail::getref(L, scope_stack::top(L));
 327                                 lua_pushstring(L, m_name.c_str());
 328                                 lua_pushvalue(L, -3);
 329                                 lua_settable(L, -3);
 330                                 lua_pop(L, 1);
 331                         }
 332
 333                         scope_stack::push(L);
 334
 335                         for (std::vector<detail::scoped_object*>
 336                                                 ::const_iterator i = m_children.begin()
 337                                                                                         ; i != m_children.end()
 338                                                                                         ; ++i)
 339                         {
 340                                 detail::scoped_object* ptr = *i;
 341                                 ptr->commit(L);
 342                         }
 343
 344                         scope_stack::pop(L);
 345                 }
 346
 347         private:
 348 #ifndef NDEBUG
 349                 bool m_cloned;
 350 #endif
 351                 mutable std::vector<detail::scoped_object*> m_children;
 352                 lua_State* m_state;
 353                 std::string m_name;
 354         };
 355
 356         typedef scope namespace_;
 357 }
 358
 359 #endif // LUABIND_SCOPE_HPP_INCLUDED