basic_errc_type.hpp

Go to the documentation of this file.

#ifndef BSL_BASIC_ERRC_TYPE_HPP
#define BSL_BASIC_ERRC_TYPE_HPP

#include "cstdint.hpp"
#include "string_view.hpp"
#include "discard.hpp"
#include "move.hpp"

namespace bsl
{
    template<typename T = bsl::int32, T SUCCESS = 0>
    class basic_errc_type final
    {
    public:
        using value_type = T;
        using reference_type = T &;
        using const_reference_type = T const &;

        constexpr basic_errc_type(    // PRQA S 2180 // NOLINT
            value_type const &errc = SUCCESS) noexcept
            : m_errc{errc}
        {}

        ~basic_errc_type() noexcept = default;

        constexpr basic_errc_type(basic_errc_type const &o) noexcept = default;

        constexpr basic_errc_type(basic_errc_type &&o) noexcept = default;

        constexpr basic_errc_type &operator=(basic_errc_type const &o) &noexcept = default;

        constexpr basic_errc_type &operator=(basic_errc_type &&o) &noexcept = default;

        template<typename O>
        basic_errc_type(O val) noexcept = delete;    // PRQA S 2180

        [[nodiscard]] constexpr const_reference_type
        get() const noexcept
        {
            return m_errc;
        }

        [[nodiscard]] constexpr bool
        success() const noexcept
        {
            return m_errc == SUCCESS;
        }

        [[nodiscard]] constexpr bool
        failure() const noexcept
        {
            return m_errc != SUCCESS;
        }

        [[nodiscard]] constexpr bool
        is_checked() const noexcept
        {
            return m_errc < 0;
        }

        [[nodiscard]] constexpr bool
        is_unchecked() const noexcept
        {
            return m_errc > 0;
        }

        [[nodiscard]] constexpr bsl::string_view message() const noexcept;

    private:
        T m_errc;
    };

    template<typename T1, T1 SUCCESS1, typename T2, T2 SUCCESS2>
    constexpr bool
    operator==(
        basic_errc_type<T1, SUCCESS1> const &lhs, basic_errc_type<T2, SUCCESS2> const &rhs) noexcept
    {
        return lhs.get() == rhs.get();
    }

    template<typename T1, T1 SUCCESS1, typename T2, T2 SUCCESS2>
    constexpr bool
    operator!=(
        basic_errc_type<T1, SUCCESS1> const &lhs, basic_errc_type<T2, SUCCESS2> const &rhs) noexcept
    {
        return !(lhs == rhs);
    }
}

// -----------------------------------------------------------------------------
// Pre-defined Error Codes
// -----------------------------------------------------------------------------

namespace bsl
{
    constexpr basic_errc_type<> errc_success{0};
    constexpr basic_errc_type<> errc_failure{1};
    constexpr basic_errc_type<> errc_precondition{2};
    constexpr basic_errc_type<> errc_postcondition{3};
    constexpr basic_errc_type<> errc_assetion{4};

    constexpr basic_errc_type<> errc_invalid_argument{10};
    constexpr basic_errc_type<> errc_index_out_of_bounds{11};
    constexpr basic_errc_type<> errc_bad_function{12};

    constexpr basic_errc_type<> errc_unsigned_wrap{30};
    constexpr basic_errc_type<> errc_narrow_overflow{31};
    constexpr basic_errc_type<> errc_signed_overflow{32};
    constexpr basic_errc_type<> errc_divide_by_zero{33};
    constexpr basic_errc_type<> errc_nullptr_dereference{34};
}

// -----------------------------------------------------------------------------
// Implementation
// -----------------------------------------------------------------------------

namespace bsl
{
    template<typename T, T SUCCESS>
    [[nodiscard]] constexpr bsl::string_view
    basic_errc_type<T, SUCCESS>::message() const noexcept
    {
        bsl::string_view msg{};

        switch (m_errc) {
            case errc_success.get(): {
                msg = "success";
                break;
            }

            case errc_failure.get(): {
                msg = "general failure";
                break;
            }

            case errc_precondition.get(): {
                msg = "general precondition failure";
                break;
            }

            case errc_postcondition.get(): {
                msg = "general postcondition failure";
                break;
            }

            case errc_assetion.get(): {
                msg = "general assertion failure";
                break;
            }

            case errc_invalid_argument.get(): {
                msg = "invalid argument (precondition) failure";
                break;
            }

            case errc_index_out_of_bounds.get(): {
                msg = "index out of bounds (precondition) failure";
                break;
            }

            case errc_bad_function.get(): {
                msg = "function not callable (precondition) failure";
                break;
            }

            case errc_unsigned_wrap.get(): {
                msg = "unsigned wrap (assertion) failure";
                break;
            }

            case errc_narrow_overflow.get(): {
                msg = "narrow overflow (assertion) failure";
                break;
            }

            case errc_signed_overflow.get(): {
                msg = "signed overflow (assertion) failure";
                break;
            }

            case errc_divide_by_zero.get(): {
                msg = "divide by zero (assertion) failure";
                break;
            }

            case errc_nullptr_dereference.get(): {
                msg = "null dereference (assertion) failure";
                break;
            }

            default: {
                break;
            }
        }

        return msg;
    }
}

#endif