memory_owned_or_reference.h

#ifndef SOURCEMETA_CORE_MEMORY_OWNED_OR_REFERENCE_H_
#define SOURCEMETA_CORE_MEMORY_OWNED_OR_REFERENCE_H_
 
#include <cassert>     // assert
#include <concepts>    // std::move_constructible, std::copy_constructible
#include <memory>      // std::addressof
#include <optional>    // std::optional, std::nullopt_t
#include <type_traits> // std::is_object_v
#include <utility>     // std::move
 
namespace sourcemeta::core {

template <typename T>
concept Ownable = std::is_object_v<T> && std::move_constructible<T>;

template <Ownable T> class OwnedOrReference {
public:
  OwnedOrReference() = default;

  // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
  OwnedOrReference([[maybe_unused]] const std::nullopt_t value) {}

  // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
  OwnedOrReference(std::optional<T> &&value) : owned_{std::move(value)} {}

  // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
  OwnedOrReference(T &&value) : owned_{std::move(value)} {}

  // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
  OwnedOrReference(const T &value) : referenced_{std::addressof(value)} {}
 
  // A constant temporary would otherwise bind to the referencing constructor
  // and leave a dangling pointer behind
  OwnedOrReference(const T &&value) = delete;
 
  // Prevent accidental copies, as copying is the very thing this type exists
  // to avoid. Take ownership through `to_owned` instead
  OwnedOrReference(const OwnedOrReference &) = delete;
  auto operator=(const OwnedOrReference &) -> OwnedOrReference & = delete;
  OwnedOrReference(OwnedOrReference &&) = default;
  auto operator=(OwnedOrReference &&) -> OwnedOrReference & = default;
  ~OwnedOrReference() = default;

  [[nodiscard]] auto has_value() const noexcept -> bool {
    return this->referenced_ != nullptr || this->owned_.has_value();
  }

  [[nodiscard]] auto value() const -> const T & {
    assert(this->has_value());
    return this->referenced_ != nullptr ? *this->referenced_
                                        : this->owned_.value();
  }

  [[nodiscard]] auto operator*() const -> const T & { return this->value(); }

  [[nodiscard]] auto operator->() const -> const T * {
    return std::addressof(this->value());
  }

  [[nodiscard]] auto to_owned() && -> T
    requires std::copy_constructible<T>
  {
    assert(this->has_value());
    if (this->referenced_ != nullptr) {
      return *this->referenced_;
    }
 
    return std::move(this->owned_).value();
  }
 
private:
  std::optional<T> owned_;
  const T *referenced_{nullptr};
};
 
} // namespace sourcemeta::core
 
#endif