LuaTempResult.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_TEMPRESULT_INCLUDED
#define LUA_ICXX_TEMPRESULT_INCLUDED

#include <string>
#include <cassert>

#include "lua_icxx_export.h"
#include "LuaCallStatus.h"
#include "LuaAdapters.h"


// used by operators for safe comparison of char*
template <typename TT> 
struct ValueType 
{ 
    typedef TT Type; 
};


template <> 
struct ValueType<const char*> 
{ 
    typedef std::string Type; 
};


template <int N> 
struct ValueType<char[N]> 
{ 
    typedef std::string Type; 
};


class LUA_ICXX_CPP_API
LuaTempResult
{
public:
    LuaTempResult( lua_State*, int prevStackTop, int errCode = 0, const std::string& errMsgPrefix = "");
    ~LuaTempResult();

    bool ok() const { return ! isError(); }
    bool isError() const { return mErrCode != LUA_ERR_NONE; }
    int getErrCode() const { return mErrCode; }
    inline std::string getErrMsg() const;

    size_t getNumItems() const { return mNumRetVal; }
    static const int FIRST_ITEM_INDEX = 1;
    class Item;



    inline Item getItem(int index = FIRST_ITEM_INDEX) const;
    inline Item operator[](int index) const;

    inline bool isNil(int indx = FIRST_ITEM_INDEX) const;


    template <typename TT> 
    inline TT getAs(int indx = FIRST_ITEM_INDEX) const;
    template <typename TT>
    inline operator TT() const { return getAs<TT>(); }


    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); }

    inline int getStackPos(int index) const;

    lua_State* getLuaState() const { return mLua; }

    inline void push(int index = FIRST_ITEM_INDEX) const;

public:
    LuaTempResult(const LuaTempResult& rhs);

private:
    // prevent resetting
    void operator=(const LuaTempResult& rhs);

private:
    lua_State * mLua;

    //LuaCallStatus mStatus;
    LuaErrCode mErrCode; 
    const int mPrevStackTop;
    const int mNumRetVal;
};


class LUA_ICXX_CPP_API 
LuaTempResult::Item
{
public:
    Item(lua_State* lua, int stackPos, LuaErrCode errCode)
        : mLua(lua), mStackPos(stackPos), mErrCode(errCode) { assert(lua); }

public:
    int getTypeID() const { return isInvalid() ? LUA_TNIL : lua_type(mLua, mStackPos); }
    bool isNil() const { return isInvalid() ? true : lua_isnil(mLua, mStackPos); }

    inline void push() const;
    bool isError() const { return mErrCode != LUA_ERR_NONE; }


    template <typename TT>
        inline operator TT() const { return getAs<TT>(); }
    template <typename TT> 
        inline TT getAs() const { return 
            getObjFromStack<TT>(mLua, mErrCode ? LUA_UNACCEPTABLE_STACK_POS : mStackPos); } 


    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); }

private:
    bool isInvalid() const { return mErrCode || mStackPos == LUA_UNACCEPTABLE_STACK_POS; }

public:
    lua_State * const mLua; 
    int const mStackPos;    
    LuaErrCode const mErrCode; 
};


inline 
LuaTempResult::LuaTempResult( 
     lua_State* lua, int prevStackTop, int errCode, const std::string& errMsgPrefix)
     : mLua(lua)
     , mErrCode(LuaErrCode(errCode))
     , mPrevStackTop(prevStackTop)
     , mNumRetVal(lua_gettop(lua) - prevStackTop)
{
    assert( lua );
    assert( mNumRetVal >= 0 );
    // if error, only one value returned: the error message
    assert( (mErrCode == LUA_ERR_NONE) || (mNumRetVal == 1));
    if (mErrCode)
    {
        // replace err message that is on stack with the correct one
        const std::string errMsg 
            = errMsgPrefix + ": " + lua_tostring(lua, prevStackTop+1);
        assert( lua_checkstack(mLua, 1) );
        lua_pushstring(lua, errMsg.c_str());
        lua_replace(lua, prevStackTop+1);
    }
}


inline 
LuaTempResult::~LuaTempResult()
{
    assert( lua_gettop(mLua) == mPrevStackTop +  mNumRetVal );
    lua_settop(mLua, mPrevStackTop);
}


/*  Get the stack position of item[index] (index=1 is first, -1 last, etc).
    If index=0 or > getNumItems() or < -getNumItems(), returns 0 (invalid stack
    position). Note that if isError(), returns the stack position of error
    message, regardless of index. 
    */
int 
LuaTempResult::getStackPos(int index) 
const
{
    if (index > 0 && index <= mNumRetVal)
        return mErrCode 
            ? mPrevStackTop + 1
            : mPrevStackTop + index + (1 - FIRST_ITEM_INDEX);

    if (index < 0 && index >= -mNumRetVal)
        return mErrCode 
            ? mPrevStackTop + 1
            : mPrevStackTop + mNumRetVal + 1 + index;

    return LUA_UNACCEPTABLE_STACK_POS;
}


template <typename TT> 
inline TT 
LuaTempResult::getAs(int index) 
const 
{ 
    return getObjFromStack<TT>( mLua, getStackPos(index) ); 
}


inline bool 
isStackPosAcceptable(lua_State* lua, int pos)
{
    return pos != 0 && abs(pos) <= lua_gettop(lua);
    //(pos > 0 && pos <= LUA_STACK_SIZE) || (pos < 0 && abs(pos) <= lua_gettop(lua));
}


inline void 
pushValToStack(lua_State* L, const LuaTempResult::Item& objRef) 
{ 
    assert( L == objRef.mLua );
    if ( objRef.mErrCode )
    {
        assert( lua_checkstack(L, 1) );
        lua_pushnil(L);
    }
    else
        objRef.push();
}


inline void 
pushValToStack(lua_State* L, const LuaTempResult& res) 
{ 
    res.push();
}


inline bool 
LuaTempResult::isNil(int indx) 
const 
{ 
    if ( mErrCode ) return true;
    const int stackPos = getStackPos(indx);
    return isStackPosAcceptable(mLua, stackPos) ? lua_isnil(mLua, stackPos) : true; 
}


inline void 
LuaTempResult::push(int index) 
const 
{ 
    if ( mErrCode ) 
        lua_pushnil(mLua); 
    else 
    {
        const int stackPos = getStackPos(index);
        assert( lua_checkstack(mLua, 1) );
        if ( isStackPosAcceptable(mLua, stackPos) )
            lua_pushvalue(mLua, stackPos);
        else
            lua_pushnil(mLua); 
    }
}


inline std::string 
LuaTempResult::getErrMsg() 
const 
{
    return mErrCode ? lua_tostring(mLua, mPrevStackTop + 1) : "";
}


LuaTempResult::Item 
LuaTempResult::getItem( int index ) const
{
    return Item(mLua, getStackPos(index), mErrCode);
}


inline LuaTempResult::Item 
LuaTempResult::operator[](int index) 
const 
{ 
    return getItem(index); 
}


inline void 
LuaTempResult::Item::push() 
const
{
    assert(lua_checkstack(mLua, 1));
    if ( isInvalid() )
        lua_pushnil(mLua);
    else
        lua_pushvalue(mLua, mStackPos);
}

#endif // LUA_ICXX_TEMPRESULT_INCLUDED