class axl::lua::LuaState

#include <axl_lua_LuaState.h>

class LuaState: public axl::sl::Handle
{
public:
    // construction

    LuaState();
    LuaState(lua_State* h);

    // methods

    bool
    create();

    bool
    load(
        const sl::StringRef& name,
        const sl::StringRef& source
        );

    bool
    loadFile(const sl::StringRef& fileName);

    bool
    doFile(const sl::StringRef& fileName);

    void
    openLibs();

    void
    where(int level = 1);

    void
    prepareErrorString(const sl::StringRef& string);

    void
    prepareLastErrorString();

    void
    error();

    void
    clearStack();

    int
    getTop();

    void
    setTop(int index);

    bool
    tryCheckStack(int extraSlotCount);

    void
    checkStack(int extraSlotCount);

    int
    getType(int index);

    sl::StringRef
    getTypeName(int type);

    void
    getLen(int index = -1);

    size_t
    getRawLen(int index = -1);

    void
    insert(int index);

    void
    remove(int index);

    void
    swap();

    void
    concatenate(int count = 2);

    void
    pushNil();

    void
    pushValue(int index = -1);

    void
    pushInteger(lua_Integer value);

    void
    pushBoolean(bool value);

    void
    pushString(const sl::StringRef& string);

    void
    pushFormatString_va(
        const char* format,
        axl_va_list va
        );

    void
    pushFormatString(
        const char* format,
        ...
        );

    void
    pushClosure(
        lua_CFunction func,
        size_t contextArgumentCount
        );

    void
    pushFunction(lua_CFunction func);

    void
    pushFunction(
        lua_CFunction func,
        void* context
        );

    bool
    tryCreateTable(
        size_t elementCount = 0,
        size_t memberCount = 0,
        size_t extraStackSlotCount = LUA_MINSTACK
        );

    void
    createTable(
        size_t elementCount = 0,
        size_t memberCount = 0,
        size_t extraStackSlotCount = LUA_MINSTACK
        );

    void
    getTable(int index = -2);

    void
    setTable(int index = -3);

    void
    getMember(const sl::StringRef& name);

    void
    setMember(const sl::StringRef& name);

    void
    getArrayElement(int index);

    void
    setArrayElement(int index);

    void
    setMemberInteger(
        const sl::StringRef& name,
        lua_Integer value
        );

    void
    setMemberBoolean(
        const sl::StringRef& name,
        bool value
        );

    void
    setMemberString(
        const sl::StringRef& name,
        const sl::StringRef& string
        );

    void
    setArrayElementInteger(
        int index,
        lua_Integer value
        );

    void
    setArrayElementString(
        int index,
        const sl::StringRef& string
        );

    void
    pop(size_t count = 1);

    lua_Integer
    getInteger(int index = -1);

    lua_Number
    getNumber(int index = -1);

    bool
    getBoolean(int index = -1);

    sl::StringRef
    getString(int index = -1);

    lua_Integer
    popInteger();

    bool
    popBoolean();

    sl::String
    popString();

    void
    getGlobal(const sl::StringRef& name);

    void
    setGlobal(const sl::StringRef& name);

    int
    getGlobalArrayLen(const sl::StringRef& name);

    void
    getGlobalArrayElement(
        const sl::StringRef& name,
        int index
        );

    void
    setGlobalArrayElement(
        const sl::StringRef& name,
        int index
        );

    void
    getGlobalMember(
        const sl::StringRef& name,
        const sl::StringRef& member
        );

    void
    setGlobalMember(
        const sl::StringRef& name,
        const sl::StringRef& member
        );

    lua_Integer
    getGlobalInteger(const sl::StringRef& name);

    void
    setGlobalInteger(
        const sl::StringRef& name,
        lua_Integer value
        );

    bool
    getGlobalBoolean(const sl::StringRef& name);

    void
    setGlobalBoolean(
        const sl::StringRef& name,
        bool value
        );

    sl::String
    getGlobalString(const sl::StringRef& name);

    void
    setGlobalString(
        const sl::StringRef& name,
        const sl::StringRef& string
        );

    void
    registerFunction(
        const sl::StringRef& name,
        lua_CFunction func
        );

    void
    registerFunction(
        const sl::StringRef& name,
        lua_CFunction func,
        void* context
        );

    void*
    getContext();

    int
    getUpValueIndex(int index = 1);

    void
    call(
        size_t argumentCount,
        size_t resultCount = LUA_MULTRET
        );

    bool
    PCall(
        size_t argumentCount,
        size_t resultCount = LUA_MULTRET
        );
};

Inherited Members

public:
    // typedefs

    typedef T H;

    // methods

    operator T() const;

    T
    operator->() const;

    const Handle&
    operator=(T h);

    bool
    isOpen() const;

    void
    close();

    void
    attach(T h);

    T
    detach();

    T*
    p();

    static
    T
    getInvalidHandle();