IterValue.h

#pragma once
 
#include <type_traits>
#include <optional>
 
namespace CXXIter {
 
    // ################################################################################################
    // ITERATOR OPTIONAL (supports references)
    // ################################################################################################
 
    template<typename TValue>
    class IterValue {
    private:
        using TValueDeref = std::remove_reference_t<TValue>;
        using TValueStore = std::conditional_t<
            std::is_reference_v<TValue>,
            std::reference_wrapper<TValueDeref>,
            TValue
        >;
 
        std::optional<TValueStore> inner;
 
    public:
        constexpr IterValue() noexcept {}
        constexpr IterValue(TValue value) noexcept requires std::is_reference_v<TValue> : inner(value) {}
        constexpr IterValue(const TValueDeref& value) noexcept(std::is_nothrow_copy_constructible_v<TValueDeref>)
                requires (!std::is_reference_v<TValue>) : inner(value) {}
        constexpr IterValue(TValueDeref&& value) noexcept(std::is_nothrow_move_constructible_v<TValueDeref>)
                : inner(std::forward<TValueDeref>(value)) {}
 
        constexpr IterValue& operator=(IterValue&& o) = default;
        constexpr IterValue(IterValue&& o) noexcept(std::is_nothrow_move_constructible_v<TValueDeref>)
                : inner(std::move(o.inner)) {
            o.inner.reset();
        };
 
        constexpr auto& operator=(TValueDeref&& o) {
            this->inner = std::forward<decltype(o)>(o);
            return *this;
        }
 
        constexpr inline const TValueDeref& value() const { return inner.value(); }
        constexpr inline TValueDeref& value() { return inner.value(); }
        constexpr inline const TValueDeref& value_or(TValueDeref&& def) const noexcept { return inner.value_or(def); }
        constexpr inline TValueDeref& value_or(TValueDeref&& def) noexcept { return inner.value_or(def); }
 
        constexpr bool has_value() const noexcept { return inner.has_value(); }
 
        constexpr void swap(IterValue<TValue>& o) noexcept { inner.swap(o.inner); }
 
        constexpr std::optional<TValueStore> toStdOptional() noexcept {
            return std::optional<TValueStore>(std::move(this->inner));
        }
        constexpr operator std::optional<TValueStore>() noexcept { return toStdOptional(); }
 
        template<typename TOutValue, std::invocable<TValueDeref&&> TMapFn>
        requires (!std::is_reference_v<TValue>)
        constexpr IterValue<TOutValue> map(TMapFn mapFn) {
            if(!has_value()) { return {}; }
            return mapFn(std::forward<TValueDeref>(value()));
        }
 
        template<typename TOutValue, std::invocable<TValue> TMapFn>
        requires std::is_reference_v<TValue>
        constexpr IterValue<TOutValue> map(TMapFn mapFn) {
            if(!this->has_value()) { return {}; }
            return mapFn(this->value());
        }
    };
 
}