result_type_decl.h

Go to the documentation of this file.

 
#ifndef A_UTIL_UTIL_RESULT_RESULT_TYPE_DECL_HEADER_INCLUDED
#define A_UTIL_UTIL_RESULT_RESULT_TYPE_DECL_HEADER_INCLUDED
 
#include <a_util/result/detail/result_description_decl.h>
#include <a_util/result/result_info.h>
 
#include <utility> //std::swap
 
namespace a_util {
namespace result {
namespace detail {
// forward declaration
class IErrorDescription;
 
} // namespace detail

class Result {
public: // construction
    Result();

    Result(bool val);

    Result(const ResultInfo<void>&);

    template <typename ErrorType>
    Result(const ResultInfo<ErrorType>& error);

    template <typename ErrorType>
    explicit Result(ResultInfo<ErrorType> error,
                    const char* error_description,
                    std::int32_t line,
                    const char* file,
                    const char* function);

    Result(std::int32_t error_code);

    explicit Result(std::int32_t error_code,
                    const char* error_description,
                    std::int32_t line,
                    const char* file,
                    const char* function);

    explicit Result(const Result& other_result,
                    const char* error_description,
                    std::int32_t line,
                    const char* file,
                    const char* function);

    ~Result();

    Result(const Result& other);

    Result& operator=(const ResultInfo<void>&);

    Result& operator=(Result other);

    Result& operator=(bool val);

    Result& operator=(std::int32_t val);

    Result(Result&& other);
 
public: // access
    std::int32_t getErrorCode() const;

    const char* getErrorLabel() const;

    const char* getDescription() const;

    std::int32_t getLine() const;

    const char* getFile() const;

    const char* getFunction() const;

    explicit operator bool() const noexcept;

    friend void swap(Result& lhs, Result& rhs);

    friend bool operator==(const Result& lhs, const Result& rhs);
 
private: // private constructor
    explicit Result(std::int32_t error_code,
                    const char* error_description,
                    std::int32_t line,
                    const char* file,
                    const char* function,
                    const char* label);

    static Result createFrom(std::int32_t error_code,
                             const char* error_description,
                             std::int32_t line,
                             const char* file,
                             const char* function);
 
private: // private member data
    typedef detail::ResultDescription<detail::IErrorDescription> DescriptionType;
    DescriptionType _result_handle; 
};                                  // class Result

bool operator!=(const Result& lhs, const Result& rhs);

template <typename T>
bool operator==(const Result& result, const ResultInfo<T>& error_code);

template <typename T>
bool operator!=(const Result& result, const ResultInfo<T>& error_code);

template <typename T>
bool operator==(const ResultInfo<T>& error_code, const Result& result);

template <typename T>
bool operator!=(const ResultInfo<T>& error_code, const Result& result);

template <>
DEV_ESSENTIAL_DEPRECATED("Please use the conversion Result::operator bool().")
bool isOk<Result>(const Result& result);
 
} // namespace result
} // namespace a_util

namespace std {
template <>
void swap<a_util::result::Result>(a_util::result::Result& lhs, a_util::result::Result& rhs);
} // namespace std
 
#include <a_util/result/detail/result_type_impl.h>
 
#endif // A_UTIL_UTIL_RESULT_RESULT_TYPE_DECL_HEADER_INCLUDED