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