base.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2019 - 2023.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SL_UTILITY_NULLABLES_BASE_HPP
#define SL_UTILITY_NULLABLES_BASE_HPP
 
#pragma once
 
#include "Simple-Utility/Config.hpp"
#include "Simple-Utility/concepts/operators.hpp"
#include "Simple-Utility/concepts/stl_extensions.hpp"
 
#include <cstddef>
#include <functional>
#include <type_traits>
 
namespace sl::nullables
{
    template <class T>
    struct traits;
 
    template <class T>
    using value_t = typename traits<std::remove_cvref_t<T>>::value_type;
 
    template <class T>
    constexpr static auto null_v{traits<std::remove_cvref_t<T>>::null};
 
    template <class T>
        requires std::is_pointer_v<T>
    struct traits<T>
    {
        using value_type = std::remove_pointer_t<T>;
        static constexpr std::nullptr_t null{nullptr};
    };
 
    namespace detail
    {
        template <class TNullable>
            requires concepts::dereferencable_r<TNullable, value_t<TNullable>>
        [[nodiscard]]
        constexpr decltype(auto) unwrap(
            TNullable&& na
        )
            noexcept
        {
            return *std::forward<TNullable>(na);
        }
 
        struct unwrap_fn
        {
            template <class TNullable>
                requires requires { { unwrap(std::declval<TNullable>()) } -> std::convertible_to<value_t<TNullable>>; }
            [[nodiscard]]
            constexpr decltype(auto) operator()(TNullable&& na) const noexcept
            {
                return unwrap(std::forward<TNullable>(na));
            }
        };
    }
 
    inline constexpr detail::unwrap_fn unwrap{};
 
    template <class T>
    concept input_nullable = requires
                            {
                                typename value_t<T>;
                                null_v<T>;
                            }
                            && concepts::weakly_equality_comparable_with<T, decltype(null_v<T>)>;
 
    template <class T>
    concept nullable = input_nullable<T>
                        && concepts::initializes<decltype(null_v<T>), std::remove_cvref_t<T>>
                        && std::is_assignable_v<std::remove_cvref_t<T>&, decltype(null_v<T>)>;
}
 
namespace sl::nullables::detail
{
    struct algorithm_tag
    {
    };
}
 
namespace sl::nullables
{
    template <concepts::unqualified Operation>
    class Algorithm
    {
    public:
        [[nodiscard]]
        explicit Algorithm(Operation operation) noexcept(std::is_nothrow_move_constructible_v<Operation>)
            : m_Operation{std::move(operation)}
        {
        }
 
        template <input_nullable Nullable>
            requires std::regular_invocable<Operation, Nullable>
                    && std::is_void_v<std::invoke_result_t<Operation, Nullable>>
        friend constexpr auto operator |(
            Nullable&& input,
            const Algorithm& algorithm
        ) noexcept(std::is_nothrow_invocable_v<Operation, Nullable>)
        {
            return std::invoke(algorithm.m_Operation, std::forward<Nullable>(input));
        }
 
        template <input_nullable Nullable>
            requires std::regular_invocable<Operation, Nullable>
        [[nodiscard]]
        friend constexpr auto operator |(
            Nullable&& input,
            const Algorithm& algorithm
        ) noexcept(std::is_nothrow_invocable_v<Operation, Nullable>)
        {
            return std::invoke(algorithm.m_Operation, std::forward<Nullable>(input));
        }
 
    private:
        SL_UTILITY_NO_UNIQUE_ADDRESS
        Operation m_Operation{};
    };
 
}
 
namespace sl::nullables::detail
{
    template <class T>
    using dereference_result_t = decltype(nullables::unwrap(std::declval<T>()));
}
 
#endif