luaProxy.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2009 K2FS Sistemas e Projetos Ltd.  
** All rights reserved.
**
************************************************************************/

#ifndef _LUA_PROXY_H_
#define _LUA_PROXY_H_

#include "luaConfig.h"

#include <lua.hpp>
#include <QVariant>

class LUAUTILS_API_EXPORT LuaProxy
{
public:
                
        class Base
        {
                public:
                        virtual void* getClassMetatableID() = 0;
                        
                        virtual void populateMetatable(lua_State* L, int index) = 0;
                        
                        virtual ~Base() {}
        };
                
        
        static void pushObject(lua_State* L, Base* obj);

        static void pushMetatable(lua_State* L, Base* obj);

        static bool isObject(lua_State* L, int index);

        static Base* toObject(lua_State* L, int index);
        
        template <typename T>
        static T * toObjectOfClass(lua_State* L, int index)
        {
          return dynamic_cast<T *>(toObject(L, index));
        }               

  template <typename T>
  static T* toObjectOfClass(const QVariant& v)
  {
                Base* ptrBase = (Base*)v.value<void*>();
          return dynamic_cast<T *>(ptrBase);
  }

  template <typename T>
  static T* checkObjectOfClass(lua_State* L, int index)
  {
    T* ptr = toObjectOfClass<T>(L, index);
    if(ptr)
      return ptr;
    luaL_typerror(L, index, "userdata"); // Não retorna!!!
    return NULL;
  }
                
};


template <typename T>
class LuaSimpleProxy : public LuaProxy::Base
{
public:
        LuaSimpleProxy(const T & obj) : _obj(obj) {}
        
        T & get() { return _obj; }
        
        // Implements LuaProxy::Base
        void * getClassMetatableID()
        {
                static int classID = 0;
                return &classID;
        }
        
        // Implements LuaProxy::Base
        void populateMetatable(lua_State * L, int index)
        {
                lua_pushstring(L, "__gc");
                lua_pushcfunction(L, l___gc);
                lua_settable(L, index);
        }

private:
        T _obj;  
        
        static int l___gc(lua_State * L)
        {
                // Recover the proxy object (first parameter, encapsulated
                // in a userdata):
                LuaSimpleProxy<T> * proxy = LuaProxy::toObjectOfClass< LuaSimpleProxy<T> >(L, 1);
                if (!proxy)
                        return luaL_error(L, "LuaSimpleProxy garbage collector called on incorrect object type.");
                
                // Delete it:
                delete proxy;
                
                // Done:
                return 0;
        }
};

template <typename T>
class LuaSimplePtrProxy: public LuaProxy::Base
{
public:
  LuaSimplePtrProxy(T* obj) : _obj(obj) {}

  virtual ~LuaSimplePtrProxy() { delete _obj; }

  T* get() { return _obj; }

  void release() { delete _obj; _obj = NULL; }

  // Implements LuaProxy::Base
  void * getClassMetatableID()
  {
    static int classID = 0;
    return &classID;
  }

  // Implements LuaProxy::Base
  void populateMetatable(lua_State * L, int index)
  {
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, l___gc);
    lua_settable(L, index);
  }

private:
  T* _obj;  

  static int l___gc(lua_State * L)
  {
    // Recover the proxy object (first parameter, encapsulated
    // in a userdata):
    LuaSimplePtrProxy<T> * proxy = LuaProxy::toObjectOfClass< LuaSimplePtrProxy<T> >(L, 1);
    if(!proxy)
      return luaL_error(L, "LuaSimplePtrProxy garbage collector called on incorrect object type.");

    // Delete it:
    delete proxy;

    // Done:
    return 0;
  }
};

template <typename T, const char* typeName>
class LuaSimpleTypedPtrProxy : public LuaSimplePtrProxy<T>
{
public:
  LuaSimpleTypedPtrProxy(T* obj) : LuaSimplePtrProxy(obj) {}

  // Implements LuaProxy::Base
  void populateMetatable(lua_State * L, int index)
  {
    LuaSimplePtrProxy<T>::populateMetatable(L, index);
    lua_pushstring(L, typeName);
    lua_setfield(L, index, "__typeName");
  }
};


#endif