builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/a_utils/include/a_utils/core/result.h

Go to the documentation of this file.

 
#ifndef _A_UTILS_BASE_RESULT_H_
#define _A_UTILS_BASE_RESULT_H_
 
namespace A_UTILS_NS
{
 
class cResult
{
public: //construction
    cResult();
 
    cResult(decltype(ERR_NOERROR));
 
    template<tErrorCode::error_code_type ErrorCode>
    cResult(const tError<ErrorCode>& i_oError);
 
    cResult(tErrorCode i_oError);
 
    template<tErrorCode::error_code_type ErrorCode>
    explicit cResult(tError<ErrorCode> i_oError,
                     const tChar* i_strErrorDescription,
                     tInt32       i_nLine,
                     const tChar* i_strFile,
                     const tChar* i_strFunction);
 
    explicit cResult(tErrorCode::error_code_type i_nErrorCode);
 
    explicit cResult(tErrorCode::error_code_type i_nErrorCode,
                     const tChar*                i_strErrorDescription,
                     tInt32                      i_nLine,
                     const tChar*                i_strFile,
                     const tChar*                i_strFunction);
 
    explicit cResult(const cResult& i_oResult,
                     const tChar*   i_strErrorDescription,
                     tInt32         i_nLine,
                     const tChar*   i_strFile,
                     const tChar*   i_strFunction);
 
    ~cResult();
 
    cResult(const cResult& i_oOther);
 
    cResult& operator=(decltype(ERR_NOERROR));
 
    cResult& operator=(cResult i_oOther);
 
    cResult(cResult&& i_oOther);
 
public:     //access
    tErrorCode   GetErrorCode() const;
 
    const tChar* GetErrorString() const;
 
    const tChar* GetDescription() const;
 
    tInt32       GetLine() const;
 
    const tChar* GetFile() const;
 
    const tChar* GetFunction() const;
 
    template<tErrorCode::error_code_type ErrorCode>
    tBool IsEqual(const tError<ErrorCode>& i_oErrorVal) const;
 
    template<typename ... ErrorTypes>
    tBool IsEqual(const ErrorTypes&... i_oErrorVals) const;
 
    tBool IsOk() const;
 
    tBool IsFailed() const;
 
    friend void swap(cResult& i_oLHS, cResult& i_oRHS);
 
    friend tBool operator==(const cResult& i_oLHS, const cResult& i_oRHS);
 
private:    //private constructor
    explicit cResult(tErrorCode   i_nErrorCode,
                     const tChar* i_strErrorDescription,
                     tInt32       i_nLine,
                     const tChar* i_strFile,
                     const tChar* i_strFunction,
                     const tChar* i_strErrorCode);
 
    static cResult CreateFrom(tErrorCode::error_code_type i_nErrorCode,
                              const tChar*                i_strErrorDescription,
                              tInt32                      i_nLine,
                              const tChar*                i_strFile,
                              const tChar*                i_strFunction);
 
    static tErrorString GetErrorString(const tErrorCode& i_oErrorCode);
 
private:    //private member data
    typedef detail::result_description<detail::IErrorDescription> description_type; 
    description_type m_oResultHandler;            
 
private:    //helper types
    template<typename ErrorType, typename ... ErrorTypes>
    struct sErrorEval;
 
    template<typename ErrorType>
    struct sErrorEval < ErrorType > ;
};//class cResult
 
tBool operator!=(const cResult& i_oLHS, const cResult& i_oRHS);
 
inline cResult::cResult()
{
}
 
inline cResult::cResult(decltype(ERR_NOERROR)) : cResult()
{
}
 
template<tErrorCode::error_code_type ErrorCode>
inline cResult::cResult(const tError<ErrorCode>& i_oError)
    : cResult(static_cast<tErrorCode>(i_oError))
{
}
 
inline cResult::cResult(tErrorCode i_oError) 
    : m_oResultHandler(description_type::make_result_description(i_oError))
{
}
 
template<tErrorCode::error_code_type ErrorCode>
inline cResult::cResult(tError<ErrorCode> i_oError,
                        const tChar*      i_strErrorDescription,
                        tInt32            i_nLine,
                        const tChar*      i_strFile,
                        const tChar*      i_strFunction)
    : cResult(static_cast<tErrorCode>(i_oError),
              i_strErrorDescription,
              i_nLine,
              i_strFile,
              i_strFunction,
              tError<ErrorCode>::str_error_code)
{
}
 
inline cResult::cResult(tErrorCode::error_code_type i_nErrorCode)
    : cResult(tErrorCode{ i_nErrorCode })
{
}
 
inline cResult::cResult(tErrorCode::error_code_type i_nErrorCode,
                        const tChar*                i_strErrorDescription,
                        tInt32                      i_nLine,
                        const tChar*                i_strFile,
                        const tChar*                i_strFunction) :
    cResult(CreateFrom(i_nErrorCode, i_strErrorDescription, i_nLine, i_strFile, i_strFunction))
{
}
 
inline cResult::cResult(const cResult& i_oResult,
                        const tChar*   i_strErrorDescription,
                        tInt32         i_nLine,
                        const tChar*   i_strFile,
                        const tChar*   i_strFunction) :
    cResult(i_oResult.GetErrorCode(),
            i_strErrorDescription,
            i_nLine,
            i_strFile,
            i_strFunction,
            i_oResult.GetErrorString())
{
}
 
inline cResult& cResult::operator=(cResult i_oOther)
{
    swap(*this, i_oOther);
    return *this;
}
 
inline cResult& cResult::operator=(decltype(ERR_NOERROR))
{
    return cResult::operator=(cResult());
}
 
inline cResult::cResult(cResult&& i_oOther) : cResult()
{
    swap(*this, i_oOther);
    if (i_oOther.IsFailed())
    {
        i_oOther = cResult();
    }
}
 
inline tBool operator==(const cResult& i_oLHS, const cResult& i_oRHS)
{
    return i_oLHS.m_oResultHandler == i_oRHS.m_oResultHandler;
}
 
inline tBool operator!=(const cResult& i_oLHS, const cResult& i_oRHS)
{
    return !(i_oLHS == i_oRHS);
}
 
inline tBool cResult::IsOk() const
{
    return tErrorCode{} == GetErrorCode();
}
 
inline tBool cResult::IsFailed() const
{
    return !IsOk();
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool cResult::IsEqual(const tError<ErrorCode>& i_oErrorVal) const
{
    return GetErrorCode() == static_cast<tErrorCode>(i_oErrorVal);
}
 
template<typename ... ErrorTypes>
inline tBool cResult::IsEqual(const ErrorTypes&... i_oErrorVals) const
{
    return sErrorEval<ErrorTypes...>::dispatch(GetErrorCode(), i_oErrorVals...);
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool operator==(const cResult& oResult, const tError<ErrorCode>& sCode)
{
    return oResult.IsEqual(sCode);
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool operator!=(const cResult& oResult, const tError<ErrorCode>& sCode)
{
    return !oResult.IsEqual(sCode);
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool operator==(const tError<ErrorCode>& sCode, const cResult& oResult)
{
    return oResult.IsEqual(sCode);
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool operator!=(const tError<ErrorCode>& sCode, const cResult& oResult)
{
    return !oResult.IsEqual(sCode);
}
 
inline void swap(cResult& i_oLHS, cResult& i_oRHS)
{   //enable ADL
    using std::swap;
    swap(i_oLHS.m_oResultHandler, i_oRHS.m_oResultHandler);
}
 
template<typename ErrorType, typename ... ErrorTypes>
struct cResult::sErrorEval
{
    static tBool dispatch(tErrorCode i_oErrorCode,
        const ErrorType& i_oErrorVal,
        const ErrorTypes&... i_oErrorVals)
    {
        if (static_cast<tErrorCode>(i_oErrorVal) == i_oErrorCode)
        {
            return tTrue;
        }
        else
        {
            return sErrorEval<ErrorTypes...>::dispatch(i_oErrorCode, i_oErrorVals...);
        }
    }
};//template<typename ErrorType, typename ... ErrorTypes> struct sErrorEval
 
template<typename ErrorType>
struct cResult::sErrorEval<ErrorType>
{
    static tBool dispatch(tErrorCode i_oErrorCode, const ErrorType& i_oErrorVal)
    {
        return static_cast<tErrorCode>(i_oErrorVal) == i_oErrorCode;
    }
};//template<typename ErrorType> struct sErrorEval<ErrorType>
 
}//ns A_UTILS_NS
 
 
using tResult = A_UTILS_NS::cResult;
 
namespace std
{
    template<>
    inline void swap<A_UTILS_NS::cResult>(A_UTILS_NS::cResult& i_oLHS, A_UTILS_NS::cResult& i_oRHS)
    {
        A_UTILS_NS::swap(i_oLHS, i_oRHS);
    }
}
 
#endif // _A_UTILS_BASE_RESULT_H_