PResult.h

Go to the documentation of this file.

/*
 * Copyright (C) 2015-2018 Digital Barriers plc. All rights reserved.
 * Contact: http://www.digitalbarriers.com/
 *
 * This file is part of the Papillon SDK.
 *
 * You can't use, modify or distribute any part of this file without
 * the explicit written agreements of Digital Barriers.
 */

#pragma once
#include <PapillonCommon.h>
#include <PString.h>

PAPILLON_BEGIN_NAMESPACE

#define ReturnIfFailed(expr) {           \
    papillon::PResult __ret = (expr);    \
    if (__ret.Failed())                  \
      return __ret;                      \
}

 // beta
#define P_ON_FAILURE(result)        papillon::PResult __localErrorToStackIfFailure = result
#define P_RETURN(result)            return __localErrorToStackIfFailure.Push(result)
#define P_RETURN_IF_FAILURE(expr)   { papillon::PResult __ret = (expr); if (__ret.Failed()) return __localErrorToStackIfFailure.Push(__ret); }

#define ReturnIfOk(expr) {            \
    papillon::PResult __ret = (expr); \
    if (__ret.Ok())                   \
        return __ret;                 \
}

#define LogAndReturnIfFailed(expr) {                                                  \
    papillon::PResult __ret = (expr);                                                 \
    if (__ret.LogErrorIfAny(papillon::PString::Empty(), PAPILLON_SRC_POS).Failed())   \
        return __ret;                                                                 \
}

#define LogAndReturnIfFalse(expr, message) {                                 \
    bool result = (expr);                                                    \
    if (!result) {                                                           \
        papillon::PResult __ret = papillon::PResult::Error(message);         \
        __ret.LogErrorIfAny(papillon::PString::Empty(), PAPILLON_SRC_POS);   \
        return __ret;                                                        \
    }                                                                        \
}


#if !(defined(DOXYGEN_SHOULD_SKIP_THIS) || defined(SWIG))
/*
 * Few extra macros to make removal of extra comma before __VA_ARGS__ cross compiler
 * effectively it does
 * #define LogIfError( ... ) LogErrorIfAny2(PAPILLON_SRC_POS, ##__VA_ARGS__ )
 */
#define _ARG16(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
#define HAS_COMMA(...) _ARG16(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0)
#define _TRIGGER_PARENTHESIS_(...) ,

#define ISEMPTY(...)                                                    \
_ISEMPTY(                                                               \
          /* test if there is just one argument, eventually an empty    \
             one */                                                     \
          HAS_COMMA(__VA_ARGS__),                                       \
          /* test if _TRIGGER_PARENTHESIS_ together with the argument   \
             adds a comma */                                            \
          HAS_COMMA(_TRIGGER_PARENTHESIS_ __VA_ARGS__),                 \
          /* test if the argument together with a parenthesis           \
             adds a comma */                                            \
          HAS_COMMA(__VA_ARGS__ (/*empty*/)),                           \
          /* test if placing it between _TRIGGER_PARENTHESIS_ and the   \
             parenthesis adds a comma */                                \
          HAS_COMMA(_TRIGGER_PARENTHESIS_ __VA_ARGS__ (/*empty*/))      \
          )

#define PASTE5(_0, _1, _2, _3, _4) _0 ## _1 ## _2 ## _3 ## _4
#define _ISEMPTY(_0, _1, _2, _3) HAS_COMMA(PASTE5(_IS_EMPTY_CASE_, _0, _1, _2, _3))
#define _IS_EMPTY_CASE_0001 ,

#define LogIfError_H0( ... ) LogErrorIfAny2(PAPILLON_SRC_POS, __VA_ARGS__ )
#define LogIfError_H1( ... ) LogErrorIfAny2(PAPILLON_SRC_POS)
#define PASTE2(_0, _1) PASTE2H(_0, _1)
#define PASTE2H(_0, _1) _0 ## _1

#define LogIfError( ... ) PASTE2(LogIfError_H,  ISEMPTY(__VA_ARGS__)) (__VA_ARGS__)
#endif // DOXYGEN_SHOULD_SKIP_THIS or SWIG

class PAPILLON_API_CORE PResult
{
public:
    enum EReturnCode
    {
        E_OK = 0,
        E_ERROR_BAD_MEMORY_ALLOCATION = 1,
        E_FALSE,
        E_ERROR,
        E_ERROR_UNKNOWN,
        E_ERROR_BAD_CAST,
        E_ERROR_NOT_YET_IMPLEMENTED,
        E_ERROR_NOT_SUPPORTED,
        E_ERROR_NO_PRIVATE_IMPLEMENTATION,
        E_ERROR_NULL_POINTER,
        E_ERROR_SERIALISATION,
        E_ERROR_SERIALISATION_NOT_SUPPORTED,
        E_ERROR_SERIALISATION_UNSUPPORTED_FORMAT,
        E_ERROR_DESERIALISATION_READ_FAILED,
        E_ERROR_DESERIALISATION_BAD_CLASS_ID,
        E_ERROR_DESERIALISATION_UNSUPPORTED_VERSION,
        E_ERROR_DESERIALISATION_UNSUPPORTED_FORMAT,
        E_ERROR_BAD_ARGUMENT,
        E_ERROR_INVALID_STATE,
        E_ERROR_UNHANDLED_CASE,
        E_ERROR_FILE_NOT_FOUND,
        E_ERROR_END_OF_FILE,
        E_ERROR_OPEN_FILE_FOR_WRITING,
        E_ERROR_OPEN_FILE_FOR_READING,
        E_ERROR_BAD_PLUGIN_PARAMETER,
        E_ERROR_FAILED_TO_CHECKOUT_LICENSE,
        E_ERROR_BAD_URI_FORMAT,
        E_ERROR_END_OF_STREAM,
        E_ERROR_STREAM_NOT_FOUND,
        E_ERROR_SERVER_DOWN,
        E_ERROR_STREAM_NOT_AVAILABLE,
        E_ERROR_STREAM_CLOSED,
        E_ERROR_STREAM_INVALIDATED,
        E_ERROR_STREAM_KICKED,
        E_ERROR_TIMEOUT,
        E_ERROR_FAILED_TO_CHECK_LICENSE,
        E_ERROR_INVALID_LICENSE,
        E_ERROR_LICENSE_EXPIRED,
        E_ERROR_DESTRINGIFY_NOT_SUPPORTED,
        E_ERROR_UNDEFINED = 0xFFFF
    };

public:
    static const PResult C_OK;

    static const PResult C_FALSE;

    static const PResult C_ERROR_UNKNOWN;

    static const PResult C_ERROR_NULL_OBJECT;

    static const PResult C_ERROR_NOT_YET_IMPLEMENTED;

    static const PResult C_ERROR_NOT_SUPPORTED;

    static const PResult C_ERROR_NO_PRIVATE_IMPLEMENTATION;

    static const PResult C_ERROR_SERIALISATION_NOT_SUPPORTED;

    PResult() : p(0) {}

    explicit PResult(EReturnCode code);

    explicit PResult(EReturnCode code, const PString& message);

    PResult(const PResult& other);

    static PResult Error(const PString& errorMessage);

    static PResult ErrorBadCast(papillon::classid fromClassId, papillon::classid toClassId);

    static PResult ErrorNullPointer(const PString& errorMessage);

    static PResult ErrorSerialisation();

    static PResult ErrorSerialization();

    static PResult ErrorSerialisationUnsupportedFormat(papillon::ESerialisationFormat format);

    static PResult ErrorSerializationUnsupportedFormat(papillon::ESerialisationFormat format);

    static PResult ErrorDeserialisationReadFailed();

    static PResult ErrorDeserializationReadFailed();

    static PResult ErrorDeserialisationBadClassId();

    static PResult ErrorDeserializationBadClassId();

    static PResult ErrorDeserialisationUnsupportedFormat(papillon::ESerialisationFormat format);

    static PResult ErrorDeserializationUnsupportedFormat(papillon::ESerialisationFormat format);

    static PResult ErrorBadArgument(const PString& message);

    static PResult ErrorInvalidState(const PString& message);

    static PResult ErrorUnhandledCase(const PString& message);

    static PResult ErrorFileNotFound(const PString& filename);

    static PResult ErrorEndOfFile(const PString& message);

    static PResult ErrorOpenFileForWriting(const PString& filename);

    static PResult ErrorOpenFileForReading(const PString& filename);

    static PResult ErrorBadPluginParameters(const PString& message);

    static PResult ErrorFailedToCheckOutLicense(const PString& productName, const PString& productVersion, const PString& message);

    static PResult ErrorBadURIFormat(const PString& message);

    static PResult ErrorEndOfStream(const PString& message);

    static PResult ErrorStreamNotFound(const PString& message);

    static PResult ErrorServerDown(const PString& message);

    static PResult ErrorStreamNotAvailable(const PString& message);

    static PResult ErrorStreamClosed(const PString& message);

    static PResult ErrorStreamInvalidated(const PString& message);

    static PResult ErrorStreamKicked(const PString& message);

    static PResult ErrorTimeout(const PString& message);

    static PResult ErrorDestringifyNotSupported();

    ~PResult();

    PResult& operator=(const PResult& other);

    bool operator==(const PResult& other) const;

    bool operator!() const { return !Ok(); }

    operator bool() const { return Ok(); }

    EReturnCode GetCode() const;

    bool IsEndOfStream() const;

    PString GetErrorMessage() const;

    PResult& Push(const PResult& result);

    PResult& Pop();

    PResult& PrependErrorMessage(const PString& message);

    bool Ok() const;

    bool Failed() const { return !Ok(); }

    bool IsFalse() const;

    PResult& LogErrorIfAny(const PString& prefix = PString::Empty(), int32 lineNumber = 0, const PString& filename = PString::Empty());
    const PResult& LogErrorIfAny(const PString& prefix = "", papillon::int32 lineNumber = 0, const PString& filename = PString::Empty()) const
    { 
        return const_cast<PResult *>(this)->LogErrorIfAny(prefix, lineNumber, filename); 
    }

    PResult& LogErrorIfAny2(int32 lineNumber1, const PString& filename1, const PString& prefix = PString::Empty(), papillon::int32 lineNumber2 = 0, const PString& filename2 = PString::Empty());

    const PResult& LogErrorIfAny2(papillon::int32 lineNumber1, const PString& filename1, const PString& prefix = PString::Empty(), papillon::int32 lineNumber2 = 0, const PString& filename2 = PString::Empty()) const
    { 
        return const_cast<PResult *>(this)->LogErrorIfAny2(lineNumber1, filename1, prefix, lineNumber2, filename2); 
    }

    void OrDie(const PString& prefix = PString::Empty(), int32 lineNumber = 0, const PString& filename = PString::Empty()) const;

    papillon::int32 Size() const;

    PResult Write(PByteStream& os, ESerialisationFormat format = papillon::E_BINARY_FORMAT) const;

    PResult Read(PByteStream& is, papillon::ESerialisationFormat format = papillon::E_BINARY_FORMAT);

    PString ToString() const;

    friend PAPILLON_API_CORE std::ostream& operator<<(std::ostream& os, const PResult& obj);

private:
    void Destroy();
    void DeepCopy(const PResult& other);

private:
    void* p;
};

PAPILLON_END_NAMESPACE