error.h

Go to the documentation of this file.

#ifndef ERROR_H
#define ERROR_H

#include "iberbox/config.h"
#ifdef USE_SCAPIX
#include <scapix/bridge/object.h>
#endif

#include <string>

namespace iberbox {

class Error
#ifdef USE_SCAPIX
    : public scapix::bridge::object<Error>
#endif
{
public:
    enum ErrorType
    {
        E_SUCCESS       = 0,
        E_NOTFOUND      = 1,
        E_FORBIDDEN     = 2,
        E_SESSION       = 3,
        E_CRYPTO        = 4,
        E_PARAMETERS    = 5,
        E_EXPIRED       = 6,
        E_DUPLICATE     = 7,
        E_BUSY          = 8,
        E_UNKNOWN       = 9,
        E_FAST          = 10,
        E_TEMPORARY     = 11,
        E_MANY          = 12,
        E_QUOTA         = 13,
        E_TAKEDOWN      = 14,
        E_RANGE         = 15,
        E_CANCELLED     = 16,
        E_LOOP          = 17,
        E_IO            = 18,
        E_INVOICING     = 19,
        E_COUPON        = 20,
        E_INCOMPLETE    = 21,
        LAST,
    };

    static const char *getTypeName(int type)
    {
        static const char *sErrorNames[] =
        {
            "Success",
            "Not found",
            "Forbidden",
            "Session not valid",
            "Cryptographic error",
            "Wrong parameters",
            "Expired",
            "Already exists",
            "Server is busy",
            "Unknown error",
            "Too fast requests",
            "Temporarily unavailable",
            "Too many attempts",
            "Quota exceeded",
            "Taken down",
            "Range not satisfiable",
            "Cancelled",
            "Loop detected",
            "I/O error",
            "There is a problem with your invoicing information",
            "Invalid coupon",
            "Incomplete"
        };
        static_assert((sizeof(sErrorNames) / sizeof(sErrorNames[0]) == Error::LAST), "Invalid number of error names");
        return type < Error::LAST ? sErrorNames[type] : "INVALID";
    }

    static const std::string getTypeNameString(unsigned type)
    {
        return getTypeName(type);
    }

    Error(int type = E_SUCCESS) { mType = type; }
    virtual ~Error() { }
    int getType() const { return mType; }
    const char *getName() const { return getTypeName(mType); }
    const std::string getNameString() const { return getTypeNameString(mType); }

#ifndef EMSCRIPTEN
protected:
#endif

    int mType;
};

}

#endif // ERROR_H