StatusCodes.h

Go to the documentation of this file.

 
#ifndef PANDORA_STATUS_CODES_H
#define PANDORA_STATUS_CODES_H 1
 
#include <exception>
#include <string>
 
#if defined(__GNUC__) && defined(BACKTRACE)
    #include <cstdlib>
    #include <execinfo.h>
#endif
 
#define PANDORA_RETURN_RESULT_IF(StatusCode1, Operator, Command)                                        \
{                                                                                                       \
    const pandora::StatusCode statusCode(Command);                                                      \
    if (statusCode Operator StatusCode1)                                                                \
    {                                                                                                   \
        std::cout << #Command << " return " << StatusCodeToString(statusCode) << std::endl;             \
        std::cout << "    in function: " << __FUNCTION__ << std::endl;                                  \
        std::cout << "    in file:     " << __FILE__ << " line#: " << __LINE__ << std::endl;            \
        return statusCode;                                                                              \
    }                                                                                                   \
}
 
#define PANDORA_RETURN_RESULT_IF_AND_IF(StatusCode1, StatusCode2, Operator, Command)                    \
{                                                                                                       \
    const pandora::StatusCode statusCode(Command);                                                      \
    if ((statusCode Operator StatusCode1) && (statusCode Operator StatusCode2))                         \
    {                                                                                                   \
        std::cout << #Command << " return " << StatusCodeToString(statusCode) << std::endl;             \
        std::cout << "    in function: " << __FUNCTION__ << std::endl;                                  \
        std::cout << "    in file:     " << __FILE__ << " line#: " << __LINE__ << std::endl;            \
        return statusCode;                                                                              \
    }                                                                                                   \
}
 
#define PANDORA_THROW_RESULT_IF(StatusCode1, Operator, Command)                                         \
{                                                                                                       \
    const pandora::StatusCode statusCode(Command);                                                      \
    if (statusCode Operator StatusCode1)                                                                \
    {                                                                                                   \
        std::cout << #Command << " throw " << StatusCodeToString(statusCode) << std::endl;              \
        std::cout << "    in function: " << __FUNCTION__ << std::endl;                                  \
        std::cout << "    in file:     " << __FILE__ << " line#: " << __LINE__ << std::endl;            \
        throw pandora::StatusCodeException(statusCode);                                                 \
    }                                                                                                   \
}
 
#define PANDORA_THROW_RESULT_IF_AND_IF(StatusCode1, StatusCode2, Operator, Command)                     \
{                                                                                                       \
    const pandora::StatusCode statusCode(Command);                                                      \
    if ((statusCode Operator StatusCode1) && (statusCode Operator StatusCode2))                         \
    {                                                                                                   \
        std::cout << #Command << " throw " << StatusCodeToString(statusCode) << std::endl;              \
        std::cout << "    in function: " << __FUNCTION__ << std::endl;                                  \
        std::cout << "    in file:     " << __FILE__ << " line#: " << __LINE__ << std::endl;            \
        throw pandora::StatusCodeException(statusCode);                                                 \
    }                                                                                                   \
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
namespace pandora
{
 
#define STATUS_CODE_TABLE(d)                                                                            \
    d(STATUS_CODE_SUCCESS,                  "STATUS_CODE_SUCCESS"                   )                   \
    d(STATUS_CODE_FAILURE,                  "STATUS_CODE_FAILURE"                   )                   \
    d(STATUS_CODE_NOT_FOUND,                "STATUS_CODE_NOT_FOUND"                 )                   \
    d(STATUS_CODE_NOT_INITIALIZED,          "STATUS_CODE_NOT_INITIALIZED"           )                   \
    d(STATUS_CODE_ALREADY_INITIALIZED,      "STATUS_CODE_ALREADY_INITIALIZED"       )                   \
    d(STATUS_CODE_ALREADY_PRESENT,          "STATUS_CODE_ALREADY_PRESENT"           )                   \
    d(STATUS_CODE_OUT_OF_RANGE,             "STATUS_CODE_OUT_OF_RANGE"              )                   \
    d(STATUS_CODE_NOT_ALLOWED,              "STATUS_CODE_NOT_ALLOWED"               )                   \
    d(STATUS_CODE_INVALID_PARAMETER,        "STATUS_CODE_INVALID_PARAMETER"         )                   \
    d(STATUS_CODE_UNCHANGED,                "STATUS_CODE_UNCHANGED"                 )
 
#define GET_STATUS_CODE_ENUM_ENTRY(a, b)                                                                \
    a,
 
#define GET_STATUS_CODE_NAME_SWITCH(a, b)                                                               \
    case a : return b;
 
enum StatusCode
{
    STATUS_CODE_TABLE(GET_STATUS_CODE_ENUM_ENTRY)
    NUMBER_OF_STATUS_CODES
};
 
std::string StatusCodeToString(const StatusCode statusCode);
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
class StatusCodeException
{
public:
    StatusCodeException(const StatusCode statusCode);
 
    ~StatusCodeException() throw();
 
    StatusCode GetStatusCode() const;
 
    std::string ToString() const;
 
    const std::string &GetBackTrace() const;
 
private:
    const StatusCode    m_statusCode;   
    std::string         m_backTrace;    
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline StatusCodeException::StatusCodeException(const StatusCode statusCode) :
    m_statusCode(statusCode)
{
#if defined(__GNUC__) && defined(BACKTRACE)
    const size_t maxDepth = 100;
    void *stackAddresses[maxDepth];
 
    size_t stackDepth = backtrace(stackAddresses, maxDepth);
    char **stackStrings = backtrace_symbols(stackAddresses, stackDepth);
 
    m_backTrace = "\nBackTrace\n    ";
 
    for (size_t i = 0; i < stackDepth; ++i)
    {
        m_backTrace += stackStrings[i];
        m_backTrace += "\n    ";
    }
 
    free(stackStrings); // malloc()ed by backtrace_symbols
#endif
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline StatusCodeException::~StatusCodeException() throw()
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline StatusCode StatusCodeException::GetStatusCode() const
{
    return m_statusCode;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline std::string StatusCodeException::ToString() const
{
    return StatusCodeToString(m_statusCode);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const std::string &StatusCodeException::GetBackTrace() const
{
    return m_backTrace;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline std::string StatusCodeToString(const StatusCode statusCode)
{
    switch (statusCode)
    {
        STATUS_CODE_TABLE(GET_STATUS_CODE_NAME_SWITCH)
        default : return "UNKNOWN";
    }
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_STATUS_CODES_H