Lua 5.2 — объект C ++ внутри объекта (с использованием lua_lightuserdata)

Прежде всего, спасибо @siffiejoe и @greatwolf за их посты. Именно они объяснили мне, что я делаю неправильно.

Теперь мое решение. Я почти уверен, что это решение далеко не самое лучшее, но пока оно покрывает мои потребности. Если у кого-то есть предложения, посмотрите / найдите потенциальные ошибки или просто прокомментируйте, пожалуйста, сделайте это.

Решение — идея

Поскольку в LUA все lightuserdata имеют одинаковую метатабельность, я решил сделать все структуры и классы, которым я хочу передать указатель lightuserdata в LUA, одинаковое наследование от общего класса, который я назвал LMetaPointer, Этот класс опубликует метатаблицу и отображает __index а также __newindex на данные статические методы LMetaPointer::__index а также LMetaPointer::__newindex, Класс также содержит static std::map (список) указателей на все экземпляры LMetaPointer которые когда-либо были созданы. Конструктор класса гарантирует, что вновь созданный экземпляр будет добавлен на эту карту.

Всякий раз, когда в Луа, метаметод __index или же __newindex называется, соответствующий LMetaPointer::__index или же LMetaPointer::__newindex выполнен. Эти методы ищут на карте соответствующий указатель, который отвечает за вызов метода и вызывает свой собственный get или же set методы, которые определены как чисто виртуальные в LMetaPointer учебный класс.

Я знаю, что это может немного сбить с толку, поэтому сейчас я опубликую определение класса LMetaPointer

Решение — Каркас: класс LMetaPointer

//-----------------------------------------------------------------------------
#define LUA_METAPOINTER     "itse.metapointer"    //-- Name given to the metatable for all lightuserdata (instances of LMetaPointer in C++)
//-----------------------------------------------------------------------------

class LMetaPointer
{
private:
static lua_State*                           m_lua;           //-- All LMetaPointers will share a common lua State
static const luaL_Reg                       m_lmembers[];    //-- Member functions (for later expansion)
static const luaL_Reg                       m_lfunctions[];  //-- Metamethods
static std::map<LMetaPointer*, std::string> m_pointers;      //-- List of all LMetaPointer instances

std::string m_name;                  //-- Name of LUA global variable pointing to me.

static int __index(lua_State* L);    //-- Shall be mapped to __index metamethod of the metatable for all lightuserdata pointers
static int __newindex(lua_State* L); //-- Shall be mapped to __newindex metamethod of the metatable for all lightuserdata pointers

void initialize(lua_State* L);       //-- Creates the metatable (only once) and publishes it

protected:
public:
LMetaPointer(lua_State* L);
virtual ~LMetaPointer();

inline lua_State*  lua()    { return m_lua;             }
inline std::string global() { return m_name;            }
inline size_t      size()   { return m_pointers.size(); }

void setGlobal(std::string n);      //-- Shall make this pointer globally accessible to LUA

virtual int get(lua_State* L) = 0;  //-- To be implemented by inherited classes
virtual int set(lua_State* L) = 0;  //-- To be implemented by inherited classes

LMetaPointer* operator [](std::string n);
};

Теперь следует реализация класса

//-----------------------------------------------------------------------------
#define lua_checkmpointer(L)    (LMetaPointer*)luaL_checkudata(L, 1, LUA_METAPOINTER)
//-----------------------------------------------------------------------------
lua_State* LMetaPointer::m_lua = NULL;
std::map<LMetaPointer*, std::string> LMetaPointer::m_pointers;
const luaL_Reg LMetaPointer::m_lmembers[]   = { { NULL, NULL } };
const luaL_Reg LMetaPointer::m_lfunctions[] =
{
{ "__index",    LMetaPointer::__index    },
{ "__newindex", LMetaPointer::__newindex },
{ NULL, NULL }
};
//-----------------------------------------------------------------------------

LMetaPointer::LMetaPointer(lua_State* L) : m_name("")
{
//-- Make sure we have created the metatable
initialize(L);

//-- Add this pointer as of kind LUA_METAPOINTER metatable. This bit of code
//   might not be necessary here. (To be removed)
lua_pushlightuserdata(m_lua, this);
luaL_getmetatable(m_lua, LUA_METAPOINTER);
lua_setmetatable(m_lua, -2);

//-- Add myself to the map of all metapointers
m_pointers[this] = m_name;
}
//-----------------------------------------------------------------------------

LMetaPointer::~LMetaPointer()
{
//-- Remove myself from the map of metapointers
std::map<LMetaPointer*, std::string>::iterator found = m_pointers.find(this);

if(found != m_pointers.end())
m_pointers.erase(found);
}
//-----------------------------------------------------------------------------

int LMetaPointer::__index(lua_State* L)
{
//-- Obtain the object that called us and call its get method.
//   Since get and set are pure virtual, all inherited classes of LMetaPointer
//   must implement it, and, upon the call from here, the correct 'get' method
//   will be called.
LMetaPointer* p = lua_checkmpointer(L);
return p->get(L);
}
//-----------------------------------------------------------------------------

int LMetaPointer::__newindex(lua_State* L)
{
//-- Obtain the object that called us and call its set method
//   Since get and set are pure virtual, all inherited classes of LMetaPointer
//   must implement it, and, upon the call from here, the correct 'get' method
//   will be called.
LMetaPointer* p = lua_checkmpointer(L);
return p->set(L);
}
//-----------------------------------------------------------------------------

void LMetaPointer::initialize(lua_State* L)
{
//-- Only create the metatable the first time and instance of LMetaPointer is created
if(!m_lua)
{
m_lua = L;

luaL_newmetatable(m_lua, LUA_METAPOINTER);
luaL_setfuncs(L, m_lfunctions, 0);
luaL_newlib(L, m_lmembers);
}
}
//-----------------------------------------------------------------------------

void LMetaPointer::setGlobal(std::string n)
{
//-- Make myself (this) a global variable in LUA with name given by 'n'
std::map<LMetaPointer*, std::string>::iterator found = m_pointers.find(this);

if(found != m_pointers.end())
{
m_name = n;
found->second = m_name;

lua_pushlightuserdata(m_lua, this);
luaL_getmetatable(m_lua, LUA_METAPOINTER);
lua_setmetatable(m_lua, -2);
lua_setglobal(m_lua, m_name.c_str());
}
}
//-----------------------------------------------------------------------------

LMetaPointer* LMetaPointer::operator [](std::string n)
{
//-- Simply for completeness, allow all metapointer access all other by their
//   name. (Notice though that since names are only assigned to instances made
//   global, this operator will only work properly when searching for a pointer
//   made global. ALl othe rpointers have an empty name.
std::map<LMetaPointer*, std::string>::iterator iter = m_pointers.begin();

while(iter != m_pointers.end())
{
if(iter->second == n)
return iter->first;
++iter;
}

return NULL;
}

Теперь этот класс позволит мне определить любую другую структуру или класс и передать LUA указатель (lightuserdata) на него без смешения методов или имен. Для примера в моем первоначальном вопросе это означает определение следующего:

ПРИМЕЧАНИЕ: я немного расширил мой пример и теперь называется LMeasLimit предыдущий TLimit, LMeasurement это новый класс в целом и LTest предыдущий TMeaasurement

Решение — Внедрение

//-------------------------------------------------------------------------

struct LMeasLimit : public LMetaPointer
{
bool   enabled;     //-- Is the limit enabled?
double value;       //-- Limit value;

LMeasLimit(lua_State* L) : LMetaPointer(L), enabled(false), value(0.0) {}
~LMeasLimit() {}

int get(lua_State* L);   //-- Implements LMetaPointer::get
int set(lua_State* L);   //-- Implements LMetaPointer::set
};
//-------------------------------------------------------------------------

struct LMeasurement : public LMetaPointer
{
double      value;      //-- Measurement
LStepResult result;     //-- Result of test
std::string message;    //-- Message to display

LMeasurement(lua_State* L) : LMetaPointer(L), value(0.0), result(srNothing), message("") {}
~LMeasurement() {}

int get(lua_State* L);   //-- Implements LMetaPointer::get
int set(lua_State* L);   //-- Implements LMetaPointer::set
};
//-------------------------------------------------------------------------

struct LTest : public LMetaPointer
{
int          id;    //-- ID of test
std::string  name;  //-- Name of test
LMeasLimit   max;   //-- Max limit for measure
LMeasLimit   min;   //-- Min limit for measure
LMeasurement meas;  //-- Measurement

LTest(lua_State* L) : LMetaPointer(L), id(0), name(""), min(L), max(L), meas(L) {}
~LTest() {}

int get(lua_State* L);   //-- Implements LMetaPointer::get
int set(lua_State* L);   //-- Implements LMetaPointer::set
};

//-----------------------------------------------------------------------------

И определение разных методов для разных классов

int LMeasLimit::get(lua_State* L)
{
std::string key = std::string(luaL_checkstring(L, 2));

if(key.find("enabled") == 0)
lua_pushboolean(L, enabled);
else if(key.find("value") == 0)
lua_pushnumber(L, value);
else
return 0;

return 1;
}
//-----------------------------------------------------------------------------

int LMeasLimit::set(lua_State* L)
{
std::string key = std::string(luaL_checkstring(L, 2));

if(key.find("enabled") == 0)
enabled = lua_toboolean(L, 3);
else if(key.find("value") == 0)
value = lua_tonumber(L, 3);

return 0;
}
//-----------------------------------------------------------------------------int LMeasurement::get(lua_State* L)
{
std::string key = std::string(luaL_checkstring(L, 2));

if(key.find("value") == 0)
lua_pushnumber(L, value);
else if(key.find("result") == 0)
lua_pushunsigned(L, result);
else if(key.find("message") == 0)
lua_pushstring(L, message.c_str());
else
return 0;

return 1;
}
//-----------------------------------------------------------------------------

int LMeasurement::set(lua_State* L)
{
std::string key = std::string(luaL_checkstring(L, 2));

if(key.find("value") == 0)
value = lua_tonumber(L, 3);
else if(key.find("result") == 0)
result = LStepResult(lua_tounsigned(L, 3));
else if(key.find("message") == 0)
message = std::string(lua_tostring(L, 3));

return 0;
}
//-----------------------------------------------------------------------------int LTest::get(lua_State* L)
{
std::string key = std::string(luaL_checkstring(L, 2));

if(key.find("id") == 0)
lua_pushinteger(L, id);
else if(key.find("name") == 0)
lua_pushstring(L, name.c_str());
else if(key.find("min") == 0)
{
lua_pushlightuserdata(L, &min);
luaL_getmetatable(L, LUA_METAPOINTER);
lua_setmetatable(L, -2);
}
else if(key.find("max") == 0)
{
lua_pushlightuserdata(L, &max);
luaL_getmetatable(L, LUA_METAPOINTER);
lua_setmetatable(L, -2);
}
else if(key.find("meas") == 0)
{
lua_pushlightuserdata(L, &meas);
luaL_getmetatable(L, LUA_METAPOINTER);
lua_setmetatable(L, -2);
}
else
return 0;

return 1;
}
//-----------------------------------------------------------------------------

int LTest::set(lua_State* L)
{
std::string key = std::string(luaL_checkstring(L, 2));

if(key.find("id") == 0)
id = lua_tointeger(L, 3);
else if(key.find("name") == 0)
name = std::string(lua_tostring(L, 3));

return 0;
}

Решение — собрать все вместе
Окончательная модификация находится в LEngine::runScript из нашего оригинального вопроса.

int LEngine::runScript(std::string scrName)
{
luaInit();

if(m_lua)
{
LTest tst(m_lua);

tst.name = std::string("mierda_esta");
tst.setGlobal("step");

if(luaL_loadfile(m_lua, scrName.c_str()) || lua_pcall(m_lua, 0, 0, 0))
processLuaError();
}

return 0;
}

Наконец, я покажу один из сценариев LUA, которые я использовал для тестирования, и его вывод.

Тестирование — скрипт LUA

print("step.id          = " .. step.id)
print("step.name        = " .. step.name)
print(step.min.enabled)
print("step.min.value   = " .. step.min.value)step.id = 1
step.name = "nombre del test";
step.min.enabled = true;
step.min.value   = 5.6;

print("step.id          = " .. step.id)
print("step.name        = " .. step.name)
print(step.min.enabled)
print("step.min.value   = " .. step.min.value)

Тестирование — Выход

step.id          = 0
step.name        = mierda_esta
false
step.min.value   = 0
step.id          = 1
step.name        = nombre del test
true
step.min.value   = 5.6

Так что теперь все работает так, как я хотел. Я все еще должен изменить это LMetaPointer чтобы теперь можно было вызывать функции-члены любого унаследованного класса аналогично тому, как мы это делаем в C ++. Но это будет другая история.

Еще раз спасибо @siffiejoe и @greatwolf за их время и ответы.