optref.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <concepts>
#include <optional>
#include <type_traits>
#include <utility>
 
namespace liber {
template <typename T>
concept not_reference = !std::is_reference_v<T>;
 
template <typename T>
    requires not_reference<T>
struct optref {
    using value_type = T;
 
    using reference_type = std::add_lvalue_reference_t<T>;
 
    using const_reference_type = std::add_const_t<reference_type>;
 
    using reference_wrapper_type = std::reference_wrapper<value_type>;
 
    constexpr optref() noexcept : opt(std::nullopt) {}
 
    constexpr optref(std::nullopt_t) noexcept : opt(std::nullopt) {}
 
    constexpr optref(const optref& other) noexcept : opt(other.opt) {}
 
    template <typename U>
        requires std::convertible_to<U, T>
    constexpr optref(const optref<U>& other) noexcept
        : optref([&]() -> optref {
              if (!other.has_reference())
                  return std::nullopt;
              return static_cast<reference_type>(other.reference());
          }()) {}
 
    constexpr optref(T& reference) noexcept
        : opt(reference_wrapper_type(reference)) {}
 
    constexpr optref(std::reference_wrapper<T> wrapper) noexcept
        : opt(wrapper) {}
 
    constexpr optref(T* pointer) noexcept
        : optref([&]() -> optref {
              if (!pointer)
                  return std::nullopt;
              return *pointer;
          }()) {}
 
    constexpr bool has_reference() const noexcept {
        return this->opt.has_value();
    }
 
    explicit constexpr operator bool() const noexcept {
        return static_cast<bool>(this->opt);
    }
 
    constexpr reference_type reference() {
        return this->opt.value();
    }
 
    constexpr const_reference_type reference() const {
        return this->opt.value();
    }
 
    // Other std::optional functions
    // std::optional::operator(s) *,-> and std::optional::value_or aren't
    // applicable to references Would overload operator . if it was possible
 
    void swap(optref& other) noexcept {
        this->opt.swap(other.opt);
    }
 
    void reset() noexcept {
        this->opt.reset();
    }
 
private:
    std::optional<reference_wrapper_type> opt;
};
} // namespace liber