optional.h

// Copyright 2026 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#pragma once
 
#include <new>
#include <type_traits>
#include <utility>
 
#ifdef __cpp_concepts
#include <concepts>
#endif  // __cpp_concepts
 
#include "pw_assert/assert.h"
#include "pw_containers/internal/optional_data.h"
 
namespace pw::containers::internal {
 
 
#ifdef __cpp_concepts
template <typename T>
concept OptionalState = std::regular<T>;
#define PW_OPTIONAL_STATE OptionalState
#else
#define PW_OPTIONAL_STATE
#endif  // __cpp_concepts
 
template <typename T,
          PW_OPTIONAL_STATE auto kHasValueState,
          bool IsTriviallyDestructible = std::is_trivially_destructible_v<T>>
class Optional final : private OptionalData<T,
                                            decltype(kHasValueState),
                                            kHasValueState,
                                            IsTriviallyDestructible>,
                       private CopyCtorBase<T>,
                       private MoveCtorBase<T>,
                       private CopyAssignBase<T>,
                       private MoveAssignBase<T> {
 private:
  template <typename, PW_OPTIONAL_STATE auto, bool>
  friend class Optional;
 
  using Base = OptionalData<T,
                            decltype(kHasValueState),
                            kHasValueState,
                            IsTriviallyDestructible>;
 
 public:
  using state_type = decltype(kHasValueState);
  using value_type = T;
 
  Optional() = delete;
 
  explicit constexpr Optional(state_type state) : Base(state) {}
 
  constexpr Optional(const value_type& value) : Base(value) {}
  constexpr Optional(value_type&& value) : Base(std::move(value)) {}
 
  template <typename... Args>
  explicit constexpr Optional(std::in_place_t, Args&&... args)
      : Base(std::in_place, std::forward<Args>(args)...) {}
 
  constexpr Optional(const Optional&) = default;
  constexpr Optional& operator=(const Optional&) = default;
  constexpr Optional(Optional&&) = default;
  constexpr Optional& operator=(Optional&&) = default;
 
  template <
      typename U,
      std::enable_if_t<std::conjunction_v<std::negation<std::is_same<T, U>>,
                                          std::is_constructible<T, const U&>,
                                          std::is_convertible<const U&, T>>,
                       int> = 0>
  constexpr Optional(const Optional<U, kHasValueState>& other) : Base(other) {}
 
  template <
      typename U,
      std::enable_if_t<
          std::conjunction_v<std::negation<std::is_same<T, U>>,
                             std::is_constructible<T, const U&>,
                             std::negation<std::is_convertible<const U&, T>>>,
          int> = 0>
  explicit constexpr Optional(const Optional<U, kHasValueState>& other)
      : Base(other) {}
 
  template <
      typename U,
      std::enable_if_t<std::conjunction_v<std::negation<std::is_same<T, U>>,
                                          std::is_constructible<T, U&&>,
                                          std::is_convertible<U&&, T>>,
                       int> = 0>
  constexpr Optional(Optional<U, kHasValueState>&& other)
      : Base(std::move(other)) {}
 
  template <typename U,
            std::enable_if_t<
                std::conjunction_v<std::negation<std::is_same<T, U>>,
                                   std::is_constructible<T, U&&>,
                                   std::negation<std::is_convertible<U&&, T>>>,
                int> = 0>
  explicit constexpr Optional(Optional<U, kHasValueState>&& other)
      : Base(std::move(other)) {}
 
  constexpr Optional& operator=(const value_type& value) {
    this->Assign(value);
    return *this;
  }
 
  constexpr Optional& operator=(value_type&& value) {
    this->Assign(std::move(value));
    return *this;
  }
 
  template <typename... Args>
  constexpr void emplace(Args&&... args) {
    this->Clear();
    this->MakeValue(std::forward<Args>(args)...);
    this->state_ = kHasValueState;
  }
 
  constexpr void reset(state_type state) { this->AssignState(state); }
 
  template <state_type kState>
  constexpr void reset() {
    this->template AssignState<kState>();
  }
 
  [[nodiscard]] constexpr bool has_value() const {
    return this->state_ == kHasValueState;
  }
 
  constexpr T& operator*() & { return this->data_; }
  constexpr const T& operator*() const& { return this->data_; }
 
  constexpr T&& operator*() && { return std::move(this->data_); }
  constexpr const T&& operator*() const&& { return std::move(this->data_); }
 
  constexpr T* operator->() { return &this->data_; }
  constexpr const T* operator->() const { return &this->data_; }
 
  constexpr T& value() & {
    PW_ASSERT(has_value());
    return this->data_;
  }
  constexpr const T& value() const& {
    PW_ASSERT(has_value());
    return this->data_;
  }
 
  constexpr T&& value() && {
    PW_ASSERT(has_value());
    return std::move(this->data_);
  }
  constexpr const T&& value() const&& {
    PW_ASSERT(has_value());
    return std::move(this->data_);
  }
 
  constexpr state_type state() const { return this->state_; }
 
  friend constexpr bool operator==(const Optional& lhs, const Optional& rhs) {
    if (lhs.has_value() && rhs.has_value()) {
      return *lhs == *rhs;
    }
    return lhs.state() == rhs.state();
  }
  friend constexpr bool operator!=(const Optional& lhs, const Optional& rhs) {
    return !(lhs == rhs);
  }
 
  friend constexpr bool operator==(const Optional& lhs, const T& rhs) {
    return lhs.has_value() && *lhs == rhs;
  }
  friend constexpr bool operator==(const T& lhs, const Optional& rhs) {
    return rhs == lhs;
  }
  friend constexpr bool operator!=(const Optional& lhs, const T& rhs) {
    return !(lhs == rhs);
  }
  friend constexpr bool operator!=(const T& lhs, const Optional& rhs) {
    return !(rhs == lhs);
  }
 
  static_assert(!std::is_convertible_v<T, state_type>,
                "To avoid ambiguity, T cannot be convertible to the state "
                "type. Consider using `enum class` to restrict conversions.");
  static_assert(!std::is_convertible_v<state_type, T>,
                "To avoid ambiguity, the state cannot be convertible to T "
                "type. Consider using `enum class` to restrict conversions.");
};
 
template <PW_OPTIONAL_STATE auto kHasValueState, bool IsTriviallyDestructible>
class Optional<void, kHasValueState, IsTriviallyDestructible> final {
 public:
  using state_type = decltype(kHasValueState);
  using value_type = void;
 
  constexpr Optional() = delete;
 
  constexpr Optional(const Optional&) = default;
  constexpr Optional(Optional&&) = default;
 
  constexpr Optional& operator=(const Optional&) = default;
  constexpr Optional& operator=(Optional&&) = default;
 
  explicit constexpr Optional(state_type state) : state_(state) {
    PW_ASSERT(state != kHasValueState);
  }
 
  explicit constexpr Optional(std::in_place_t) : state_(kHasValueState) {}
 
  constexpr void emplace() { state_ = kHasValueState; }
 
  constexpr void reset(state_type state) {
    PW_ASSERT(state != kHasValueState);
    state_ = state;
  }
 
  template <state_type kState>
  constexpr void reset() {
    static_assert(
        kState != kHasValueState,
        "Cannot set state to the has-value state; set the value instead");
    state_ = kState;
  }
 
  [[nodiscard]] constexpr bool has_value() const {
    return state_ == kHasValueState;
  }
 
  constexpr void value() const { PW_ASSERT(has_value()); }
 
  constexpr state_type state() const { return state_; }
 
  friend constexpr bool operator==(const Optional& lhs, const Optional& rhs) {
    return lhs.state() == rhs.state();
  }
  friend constexpr bool operator!=(const Optional& lhs, const Optional& rhs) {
    return lhs.state() != rhs.state();
  }
 
 private:
  state_type state_;
};
 
 
#undef PW_OPTIONAL_STATE
 
}  // namespace pw::containers::internal