luaruntime.hpp

/* Copyright (c) 2014-2015, The Nuria Project
 * The NuriaProject Framework is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * The NuriaProject Framework 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 Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with The NuriaProject Framework.
 * If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef NURIA_LUARUNTIME_HPP
#define NURIA_LUARUNTIME_HPP

#include <functional>
#include <QObject>

#include <nuria/metaobject.hpp>
#include "lua_global.hpp"
#include "luavalue.hpp"

class QIODevice;

namespace Nuria {

namespace Internal { class Delegate; }
class LuaCallbackTrampoline;
class LuaMetaObjectWrapper;
class LuaBuiltinFunctions;
class LuaRuntimePrivate;
class LuaMetaObject;
class Callback;

class NURIA_LUA_EXPORT LuaRuntime : public QObject {
        Q_OBJECT
public:
        
        enum LuaLib {
                Base = 0x01,
                Math = 0x02,
                String = 0x04,
                Table = 0x08,
                InputOutput = 0x10,
                OperatinSystem = 0x20,
                Package = 0x40,
                Debug = 0x80,
                Bit = 0x100,
                Jit = 0x200,
                Ffi = 0x400,
                
                AllLibraries = Base | Math | String | Table | InputOutput |
                OperatinSystem | Package | Debug | Bit | Jit | Ffi
        };
        
        Q_DECLARE_FLAGS(LuaLibs, LuaLib)
        
        
        enum Ownership {
                
                OwnedByLua = 0x1,
                
                OwnedByCpp = 0x2,
                
        };
        
        Q_DECLARE_FLAGS(OwnershipFlags, Ownership)
        
        
        explicit LuaRuntime (LuaLibs libraries, QObject *parent = 0);
        
        ~LuaRuntime () override;
        
        bool execute (const QByteArray &script);
        
        bool executeStream (QIODevice *device);
        
        LuaValue lastResult () const;
        
        LuaValues allResults () const;
        
        LuaValue global (const QString &name);
        
        void setGlobal (const QString &name, const QVariant &value);
        
        void setGlobal (const QString &name, const LuaValue &value);
        
        bool hasGlobal (const QString &name);
        
        void registerMetaObject (MetaObject *metaObject, const QByteArray &prefix = QByteArray ());
        
        void collectGarbage ();
        
        Ownership objectOwnership (void *object);
        
        void setObjectOwnership (void *object, Ownership ownership);
        
        typedef std::function< bool(Ownership, void *, MetaObject *) > ObjectHandler;
        
        void setObjectHandler (ObjectHandler handler, OwnershipFlags flags = OwnershipFlags (OwnedByLua | OwnedByCpp));
        
        void *luaState ();
        
private:
        friend class LuaCallbackTrampoline;
        friend class LuaMetaObjectWrapper;
        friend class LuaBuiltinFunctions;
        friend class Internal::Delegate;
        friend class LuaMetaObject;
        friend class LuaObject;
        
        // 
        void createObjectsReferenceTable ();
        
        bool pcall (int argCount, LuaValues &results);
        
        void setLastResultError (LuaValues &values, const QString &message);
        static QString luaErrorToString (int error);
        void createLuaInstance ();
        void openLuaLibraries (LuaLibs libraries);
        
        // 
        LuaRuntimePrivate *d_ptr;
        
};

}

#endif // NURIA_LUARUNTIME_HPP