Re: [luabind] Extra object variables

[Arvid N. <c9...@cs...>]

On Sep 5, 2005, at 07:19, Josh Green wrote:

> I've tried doing as you have below,
> with the m_self member,
> however, in the constructor, I try do do "m_self(*this)" but this  
> isn't compilable because the first parameter needs to be a  
> lua_State*, one of my probs with this is that I don't necessarily  
> have a lua_State active yet when creating the object

Yeah, sorry, I wrote the reply from the top of my head without  
confirming that it actually worked. Yes, the constructor needs a  
lua_State*.

> So I tried moving it into the constructor:
> Object::Object(){
>  if(scripting){
>    lua_self = luabind::object(scripting->getLuaState(),this);
>  }
> }
>
> This seems to work...
> But now I have a problem with classes that are derived from  
> "Object" any extra functions or properties that should be available  
> in lua arn't, (I assume this is because the luabind::object is  
> given the pointer to the Object part of the class, and thus cannot  
> tell that it should have extra members there too...)

Yes, the type if the second argument is used when creating the lua  
object that points to the c++ instance.

> The only solution i can think of is this:
> - assign the lua_self explicitly in every single derived class  
> (sounds tedious, and wouldn't that mean I have tried to assign  
> lua_self once for every level of abstraction?)
>
> Can anyone think of more/better options?

The first thing I can think of is to make the base class a template,  
like this:

template<class Derived>
class Object
{
    Object()
    {
       if (scripting)
          lua_self = luabind::object(scripting->getLuaState()
             , static_cast<Derived*>(this));
    }
    /* ... */
};

This may not be a very good solution though, since all the members of  
Object would have to be implemented in the header. An alternative  
could be have a member function template to "register" the instance  
(create the lua pointer to the instance). Something like this:

class Object
{
    template<class Derived>
    void create_lua_instance()
    {
       if (scripting)
          lua_self = luabind::object(scripting->getLuaState()
             , static_cast<Derived*>(this));
    }
    /* ... */
};

That function could then be called from the constructor of every  
derived class. Still a bit tedious though. This would, just like you  
say do the assignment once for every class in the hierarchy, from  
Object to the most derived class. It is unnecessary, but it will  
still work, since the most derived constructor will be called last of  
all, and overwrite any previous object.

The general problem here is that you want to assign the lua value  
only once, and that makes it imossible to do in the constructor  
(unless you pass an argument to the constructor telling if a derived  
class will do the assignment). Another solution could be to create  
the instance on first use. If you'd modify the above function  
slightly, it could be used for this.

    template<class Derived>
    void create_lua_instance()
    {
       if (scripting && !lua_self)
          lua_self = luabind::object(scripting->getLuaState()
             , static_cast<Derived*>(this));
    }

This will only assign the lua value if it is unassigned. So you can  
call it before every time you need it (i.e. in onClick() etc.).

--
Arvid Norberg