box.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "control_box.hpp"
 
#include <format>
 
namespace toast {
class Node;

template<typename T>
class Box {
  template<typename U>
  friend class Box;
  friend struct _detail::ControlBox;
  _detail::ControlBox* control = nullptr;
 
public:
  Box() noexcept = default;
  ~Box() noexcept;

  Box(std::nullptr_t) noexcept { }

  Box(_detail::ControlBox* control_box) noexcept;

  Box(const T* node) noexcept;

  Box(const T& node) noexcept;

  Box(const Box& other) noexcept;
  auto operator=(const Box& other) noexcept -> Box&;

  Box(Box&& other) noexcept;
  auto operator=(Box&& other) noexcept -> Box&;

  template<typename U>
    requires std::convertible_to<U*, T*>
  Box(const Box<U>& other) noexcept;

  template<typename U>
    requires std::convertible_to<U*, T*>
  auto operator=(const Box<U>& other) noexcept -> Box&;

  template<typename U>
    requires std::convertible_to<U*, T*>
  Box(Box<U>&& other) noexcept;

  template<typename U>
    requires std::convertible_to<U*, T*>
  auto operator=(Box<U>&& other) noexcept -> Box&;

  [[nodiscard]]
  auto exists() const noexcept -> bool;
 
  auto operator<=>(const Box& other) const noexcept -> std::strong_ordering;
  auto operator==(const Box& other) const noexcept -> bool;
  explicit operator bool() const noexcept;
 
  operator T&() noexcept;
  auto operator->() noexcept -> T*;
  auto operator*() noexcept -> T&;
 
  operator const T&() const noexcept;
  auto operator->() const noexcept -> const T*;
  auto operator*() const noexcept -> const T&;

  template<typename U>
    requires std::derived_from<U, T>
  [[nodiscard]]
  auto as() const noexcept -> Box<U>;

  [[nodiscard]]
  auto rid() const noexcept -> size_t;
};
 
}
 
template<typename T>
struct std::hash<toast::Box<T>> {
  auto operator()(const toast::Box<T>& a) const noexcept -> std::size_t { return std::hash<std::uintptr_t> {}(a.rid()); }
};

template<typename T>
struct std::formatter<toast::Box<T>> : std::formatter<std::string_view> {
  auto format(const toast::Box<T>& p, std::format_context& ctx) const {
    if (not p.exists()) {
      return std::format_to(ctx.out(), "(empty node)");
    }
    return std::format_to(ctx.out(), "{} ({})", p->name(), p->uid());
  }
};
 
#include "box.inl"