result.hpp

Go to the documentation of this file.

#ifndef BSL_RESULT_HPP
#define BSL_RESULT_HPP

#include "construct_at.hpp"
#include "cstdint.hpp"
#include "debug.hpp"
#include "destroy_at.hpp"
#include "errc_type.hpp"
#include "in_place.hpp"
#include "is_nothrow_constructible.hpp"
#include "is_nothrow_copy_constructible.hpp"
#include "is_nothrow_copy_assignable.hpp"
#include "is_nothrow_destructible.hpp"
#include "is_nothrow_move_constructible.hpp"
#include "is_nothrow_move_assignable.hpp"
#include "is_nothrow_swappable.hpp"
#include "is_same.hpp"
#include "move.hpp"
#include "source_location.hpp"
#include "swap.hpp"

namespace bsl
{
    namespace details
    {
        enum class result_type : bsl::uint8
        {
            contains_t,
            contains_e
        };
    }

    template<typename T, typename E = errc_type>
    class result final
    {
        static_assert(!is_same<T, E>::value);
        static_assert(is_nothrow_copy_constructible<E>::value);
        static_assert(is_nothrow_copy_assignable<E>::value);
        static_assert(is_nothrow_destructible<E>::value);
        static_assert(is_nothrow_move_constructible<E>::value);
        static_assert(is_nothrow_move_assignable<E>::value);

        static constexpr void
        private_swap(result &lhs, result &rhs) noexcept
        {
            if (details::result_type::contains_t == lhs.m_which) {
                if (details::result_type::contains_t == rhs.m_which) {
                    bsl::swap(lhs.m_t, rhs.m_t);    // NOLINT
                }
                else {
                    E tmp_e{bsl::move(rhs.m_e)};                      // NOLINT
                    destroy_at(&rhs.m_e);                             // NOLINT
                    construct_at<T>(&rhs.m_t, bsl::move(lhs.m_t));    // NOLINT
                    destroy_at(&lhs.m_t);                             // NOLINT
                    construct_at<E>(&lhs.m_e, bsl::move(tmp_e));      // NOLINT
                }
            }
            else {
                if (details::result_type::contains_t == rhs.m_which) {
                    E tmp_e{bsl::move(lhs.m_e)};                      // NOLINT
                    destroy_at(&lhs.m_e);                             // NOLINT
                    construct_at<T>(&lhs.m_t, bsl::move(rhs.m_t));    // NOLINT
                    destroy_at(&rhs.m_t);                             // NOLINT
                    construct_at<E>(&rhs.m_e, bsl::move(tmp_e));      // NOLINT
                }
                else {
                    bsl::swap(lhs.m_e, rhs.m_e);    // NOLINT
                }
            }

            bsl::swap(lhs.m_which, rhs.m_which);
        }

    public:
        using type = T;

        constexpr result(T const &t) noexcept(    // PRQA S 2180 // NOLINT
            is_nothrow_copy_constructible<T>::value)
            : m_which{details::result_type::contains_t}, m_t{t}
        {}

        constexpr result(T &&t) noexcept(    // PRQA S 2180 // NOLINT
            is_nothrow_move_constructible<T>::value)
            : m_which{details::result_type::contains_t}, m_t{bsl::move(t)}
        {}

        template<typename... ARGS>
        constexpr result(    // NOLINT
            bsl::in_place_t const &ip,
            ARGS &&... args) noexcept(is_nothrow_constructible<T, ARGS...>::value)
            : m_which{details::result_type::contains_t}, m_t{bsl::forward<ARGS>(args)...}
        {
            bsl::discard(ip);
        }

        constexpr result(    // PRQA S 2180 // NOLINT
            E const &e,
            sloc_type const &sloc = here()) noexcept
            : m_which{details::result_type::contains_e}, m_e{e}
        {
            bsl::error() << e.message() << bsl::endl;
            bsl::error() << sloc;
        }

        constexpr result(    // PRQA S 2180 // NOLINT
            E &&e,
            sloc_type const &sloc = here()) noexcept
            : m_which{details::result_type::contains_e}, m_e{bsl::move(e)}
        {
            bsl::error() << e.message() << bsl::endl;
            bsl::error() << sloc;
        }

        BSL_CONSTEXPR ~result() noexcept(is_nothrow_destructible<T>::value)
        {
            if (details::result_type::contains_t == m_which) {
                destroy_at(&m_t);    // NOLINT
            }
            else {
                destroy_at(&m_e);    // NOLINT
            }
        }

        constexpr result(result const &o) noexcept(    // PRQA S 4285
            is_nothrow_copy_constructible<T>::value)
            : m_which{o.m_which}    // PRQA S 4050
        {
            if (details::result_type::contains_t == m_which) {
                construct_at<T>(&m_t, o.m_t);    // NOLINT
            }
            else {
                construct_at<E>(&m_e, o.m_e);    // NOLINT
            }
        }

        constexpr result(result &&o) noexcept(    // PRQA S 4285
            is_nothrow_move_constructible<T>::value)
            : m_which{o.m_which}    // PRQA S 4050
        {
            if (details::result_type::contains_t == m_which) {
                construct_at<T>(&m_t, bsl::move(o.m_t));    // NOLINT
            }
            else {
                construct_at<E>(&m_e, bsl::move(o.m_e));    // NOLINT
            }
        }

        constexpr result &
        operator=(result const &o) &noexcept(
            is_nothrow_copy_constructible<T>::value &&is_nothrow_swappable<T>::value)
        {
            result tmp{o};
            private_swap(*this, tmp);
            return *this;
        }

        constexpr result &
        operator=(result &&o) &noexcept(
            is_nothrow_move_constructible<T>::value &&is_nothrow_swappable<T>::value)
        {
            result tmp{bsl::move(o)};
            private_swap(*this, tmp);
            return *this;
        }

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

        [[nodiscard]] constexpr T *
        get_if() &noexcept
        {
            if (details::result_type::contains_t == m_which) {
                return &m_t;    // PRQA S 4024 // NOLINT
            }

            return nullptr;
        }

        [[nodiscard]] constexpr T *get_if() &&noexcept = delete;

        [[nodiscard]] constexpr T const *
        get_if() const &noexcept
        {
            if (details::result_type::contains_t == m_which) {
                return &m_t;    // NOLINT
            }

            return nullptr;
        }

        [[nodiscard]] constexpr T const *get_if() const &&noexcept = delete;

        [[nodiscard]] constexpr E
        errc(E const &fallback = E{}) const noexcept
        {
            if (details::result_type::contains_e == m_which) {
                return m_e;    // NOLINT
            }

            return fallback;
        }

        [[nodiscard]] constexpr bool
        success() const noexcept
        {
            return details::result_type::contains_t == m_which;
        }

        [[nodiscard]] constexpr bool
        failure() const noexcept
        {
            return details::result_type::contains_e == m_which;
        }

    private:
        details::result_type m_which;

        union    // PRQA S 2176, 2026, 2177
        {
            T m_t;
            E m_e;
        };
    };

    template<typename T, typename E>
    constexpr bool
    operator==(result<T, E> const &lhs, result<T, E> const &rhs) noexcept
    {
        if (lhs.success() != rhs.success()) {
            return false;
        }

        if (lhs.success()) {
            return *lhs.get_if() == *rhs.get_if();
        }

        return lhs.errc() == rhs.errc();
    }

    template<typename T, typename E>
    constexpr bool
    operator!=(result<T, E> const &lhs, result<T, E> const &rhs) noexcept
    {
        return !(lhs == rhs);
    }
}

#endif