LuaObjRef.h

/*
This file is part of the Lua_icxx library. 
Copyright 2010 (c) by Oliver Schoenborn. 
License terms in LICENSE.txt.
*/


#pragma once

#ifndef LUA_ICXX_OBJREF_INCLUDED
#define LUA_ICXX_OBJREF_INCLUDED

#include <string>

#include "LuaRegistryRef.h"
#include "LuaTempResult.h"
#include "LuaStackCleaner.h"

class LuaTableRef; 
class LuaFuncRef; 


class LUA_ICXX_CPP_API
LuaObjRef
{
public:
    explicit LuaObjRef( const std::string& id = "nil" );


    LuaObjRef( const LuaTempResult& );
    LuaObjRef( const LuaTempResult::Item& );
    LuaObjRef( lua_State*, int stackPos );
    virtual ~LuaObjRef() {}

public: 


    void resetRef( const LuaTempResult& result ) { resetRef(result[1]); }
    void resetRef( const LuaTempResult::Item& );
    LuaObjRef& operator=(const LuaTempResult& result )  { resetRef(result[1]); return *this;}
    LuaObjRef& operator=(const LuaTempResult::Item& resultItem )  { resetRef(resultItem); return *this;}

    void setNil() { mRegKey.setNil(); }
    bool isNil() const { return mErrCode ? true : mRegKey.isNil(); }
    int getTypeID() const { return mErrCode ? LUA_TNIL : mRegKey.getTypeID(); }
    std::string typeName() const { return ( mLua ? lua_typename(mLua, getTypeID()) : "nil" ); }
    bool isError() const { return mErrCode != LUA_ERR_NONE; }
    std::string getErrMsg() const;

    void setID(const std::string& id) { mID = id; }
    const std::string& getID() const { return mID; }


    template <typename TT>  inline operator TT() const { return getAs<TT>(); }
    template <typename TT>  TT getAs() const;

public: // values

    template <typename TT> inline bool operator==(TT val) const { return getAs<TT>() == typename ValueType<TT>::Type(val); }
    template <typename TT> inline bool operator!=(TT val) const { return getAs<TT>() != typename ValueType<TT>::Type(val); }
    template <typename TT> inline bool operator>=(TT val) const { return getAs<TT>() >= typename ValueType<TT>::Type(val); }
    template <typename TT> inline bool operator<=(TT val) const { return getAs<TT>() <= typename ValueType<TT>::Type(val); }
    template <typename TT> inline bool operator>(TT val)  const { return getAs<TT>() >  typename ValueType<TT>::Type(val); }
    template <typename TT> inline bool operator<(TT val)  const { return getAs<TT>() <  typename ValueType<TT>::Type(val); }

public: // meta tables
    // Customize behavior of this object by changing its metatable
    bool setMetaProtected( bool val = true );
    bool hasMetaTable() const;
    void setMetaTable(const LuaTableRef&);
    LuaTempResult getMetaTable() const;
    void setMetaBase(const LuaTableRef&);
    bool hasMetaBase() const;

    enum MetaMethod
    {
        MM_ADD,           
        MM_MULTIPLY,      
        MM_SUBTRACT,      
        MM_DIVIDE,        
        MM_UNARY_MINUS,   
        MM_NEGATE,        
        MM_CONCATENATE,   

        MM_EQUAL,         
        MM_LESS_THAN,     
        MM_LESS_OR_EQUAL, 

        MM_TOSTRING,      
        MM_INDEX,         
        MM_FIELD,         
        MM_NEW_INDEX,     
        MM_NEW_FIELD,     
    };

    void setMetaMethod(MetaMethod id, const LuaFuncRef& func); 

public: // interact via C API directly
    void pushObj() const 
    { 
        if (mErrCode) 
        {
            assert( lua_checkstack(mLua, 1) ); 
            lua_pushnil(mLua); 
        }
        else 
            mRegKey.pushObj(); 
    }
    lua_State* getLuaState() const { return mLua; }

protected:
    lua_State * mLua; 

private:
    struct AutoPop;
    template <typename TT> struct DefaultValue;

    const char* getMetaMethodFromID( MetaMethod id );

private:
    LuaRegRef mRegKey;
    std::string mID;
    LuaErrCode mErrCode;
};


inline void 
pushValToStack(lua_State* L, const LuaObjRef& objRef) 
{ 
    objRef.pushObj(); 
}

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


template <typename TT> 
struct LuaObjRef::DefaultValue
{
    static inline TT value() {return 0;}
};
template <>
struct LuaObjRef::DefaultValue<const char*>
{
    static inline const char* value() {return "";}
};
template <>
struct LuaObjRef::DefaultValue<std::string>
{
    static inline std::string value() {return "";}
};


template <typename TT>
inline TT
LuaObjRef::getAs() 
const 
{ 
    if (mErrCode)
        return DefaultValue<TT>::value();

    LuaStackCleaner s(mLua); 
    mRegKey.pushObj(); 
    return getObjFromStack<TT>(mLua); 
}


#endif // LUA_ICXX_OBJREF_INCLUDED