class.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2005 by Reality Rift Studios                       *
 *   http://www.realityrift.com  -  mattias@realityrift.com                *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef neo_script_lua_class_h
#define neo_script_lua_class_h

#include "../../core/platform.h"

#if NEO_ENABLE_SCRIPT_LUA

#include "../../core/hashtable.h"
#include "../../core/type.h"
#include "classrep.h"
#include "scope.h"
#include "method.h"

extern "C" { struct lua_State; }

namespace neo {
namespace script {
namespace lua {


template< class T, class X1 = core::NullType, class X2 = core::NullType, class X3 = core::NullType, class X4 = core::NullType > class Class;
class ClassRep;
class ClassRegstry;


template < class T > struct ClassDestructor
{
    static void deleteT( void* p_ptr )
    {
        delete static_cast< T* >( p_ptr );
    }
};

struct SingletonDestructor
{
    static void deleteT( void* ) {}
};

typedef void ( *Destructor )( void* );

template < class T > class VirtualClass {};

class ClassBase : public ScopedObject
{
    public:


                                                            ClassBase( const char* p_name, const std::type_info* p_type, Destructor dtor );

    virtual                                                ~ClassBase();


    inline const char*                                      getName() const;


    virtual void                                            commit( lua_State* p_state );


    virtual ScopedObject*                                   clone();
    
    protected:


    void                                                    addBase( const BaseClassDesc& base );


    void                                                    addMethod( const char* p_name, MethodRep::Overload& method );


    void                                                    addStaticMethod( const char* p_name, MethodRep::Overload& method );


    void                                                    addConstructor( const ConstructorRep::Overload& ctor );


    void                                                    addOperator( int opid, MethodRep::Overload& method );


    void                                                    addProperty( const char* p_name, GetSetBase* p_getter, GetSetBase* p_setter );


    void                                                    addEnum( const char* p_name, int value );


    void                                                    addStaticProperty( const char* p_name, GetSetBase* p_getter );
    
    private:

    const char*                                             _p_name;

    const std::type_info*                                   _p_type;

    core::HashTable< const char*, MethodRep >               _methods;

    core::HashTable< const char*, MethodRep >               _methodsStatic;

    ConstructorRep                                          _ctor;

    core::Array< MethodRep >                                _operators;

    core::HashTable< const char*, GetSetBase* >             _getters;

    core::HashTable< const char*, GetSetBase* >             _setters;

    core::HashTable< const char*, int >                     _enums;

    core::HashTable< const char*, GetSetBase* >             _statics;
    
    Destructor                                              _dtor;

    core::Array< BaseClassDesc >                            _bases;
};


template < class T, class X1, class X2, class X3, class X4 > class Class : public ClassBase
{
    public:


    inline                                                  Class( const char* p_name );


    inline                                                  Class( const char* p_name, Destructor p_dtor );
    
    virtual                                                ~Class();


    template < class F >
    inline Class&                                           staticmethod( const char* p_name, F method );


    template < class F, class ReturnPolicy >
    inline Class&                                           staticmethod( const char* p_name, F method, const ReturnPolicy& policy );


    template < class F >
    inline Class&                                           method( const char* p_name, F method );


    template < class F, class ReturnPolicy >
    inline Class&                                           method( const char* p_name, F method, const ReturnPolicy& policy );


    template < class A0, class A1, class A2, class A3 >
    inline Class&                                           method( const Constructor< A0, A1, A2, A3 >& ctor );
    

    template < class F >
    inline Class&                                           op( int opid, F method );
    

    template < class F >
    inline Class&                                           globalop( int opid, F method );


    template < class D >
    inline Class&                                           property( const char* p_name, D T::*p_property, bool readonly = false );


    inline Class&                                           enumerate( const char* p_name, int value );


    template < class D >
    inline Class&                                           staticproperty( const char* p_name, D* p_property );
    
    private:

    template < class To > inline void                       genBaseDesc( core::TypeHolder< To > );
    template < class To > inline void                       genBaseDesc( core::TypeHolder< VirtualClass< To > > );
    inline void                                             genBaseDesc( core::TypeHolder< core::NullType > );
};

#include "class.inl"

}
}
}

#endif

#endif

---