unique_ptr.h

// Copyright 2024 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 <cstddef>
#include <type_traits>
#include <utility>
 
#include "pw_allocator/config.h"
#include "pw_allocator/deallocator.h"
#include "pw_allocator/internal/managed_ptr.h"
#include "pw_allocator/layout.h"
#include "pw_preprocessor/compiler.h"
 
namespace pw {
 
 
template <typename T>
class UniquePtr : public ::pw::allocator::internal::ManagedPtr<T> {
 private:
  using Base = ::pw::allocator::internal::ManagedPtr<T>;
  using Empty = ::pw::allocator::internal::Empty;
 
 public:
  using pointer = typename Base::element_type*;
  using element_type = typename Base::element_type;
 
  constexpr UniquePtr() noexcept;
 
  // Not copyable.
  UniquePtr(const UniquePtr&) = delete;
  UniquePtr& operator=(const UniquePtr&) = delete;
 
  constexpr UniquePtr(std::nullptr_t) noexcept : UniquePtr() {}
 
  UniquePtr(element_type* value, Deallocator& deallocator);
  UniquePtr(element_type* value, size_t size, Deallocator& deallocator);
 
  template <typename U,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  UniquePtr(UniquePtr<U>&& other) noexcept {
    *this = std::move(other);
  }
 
  ~UniquePtr() { Reset(); }
 
  template <typename U,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  UniquePtr& operator=(UniquePtr<U>&& other) noexcept;
 
  UniquePtr& operator=(std::nullptr_t) noexcept;
 
  template <typename U,
            std::enable_if_t<std::is_assignable_v<T*&, U*>, int> = 0>
  constexpr explicit operator UniquePtr<U>() &&;
 
  [[nodiscard]] friend constexpr bool operator==(const UniquePtr& lhs,
                                                 std::nullptr_t) {
    return lhs.Equals(nullptr);
  }
  [[nodiscard]] friend constexpr bool operator==(std::nullptr_t,
                                                 const UniquePtr& rhs) {
    return rhs.Equals(nullptr);
  }
  [[nodiscard]] friend constexpr bool operator==(const UniquePtr& lhs,
                                                 const UniquePtr& rhs) {
    return lhs.Equals(rhs) && lhs.control_block_ == rhs.control_block_;
  }
 
  [[nodiscard]] friend constexpr bool operator!=(const UniquePtr& lhs,
                                                 std::nullptr_t) {
    return !lhs.Equals(nullptr);
  }
  [[nodiscard]] friend constexpr bool operator!=(std::nullptr_t,
                                                 const UniquePtr& rhs) {
    return !rhs.Equals(nullptr);
  }
  [[nodiscard]] friend constexpr bool operator!=(const UniquePtr& lhs,
                                                 const UniquePtr& rhs) {
    return !(lhs == rhs);
  }
 
  size_t size() const;
 
  Deallocator* deallocator() const { return deallocator_; }
 
  element_type* Release() noexcept;
 
  void Reset() noexcept;
 
  void Swap(UniquePtr& other);
 
 private:
  // Allow construction with to the implementation of `MakeUnique`.
  friend class Deallocator;
 
  // Allow UniquePtr<T> to access UniquePtr<U> and vice versa.
  template <typename>
  friend class UniquePtr;
 
  template <typename U,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  void CopyFrom(const UniquePtr<U>& other);
 
  PW_NO_UNIQUE_ADDRESS
  std::conditional_t<std::is_array_v<T>, size_t, Empty> size_;
 
  Deallocator* deallocator_ = nullptr;
};
 
 
// Template method implementations.
 
template <typename T>
constexpr UniquePtr<T>::UniquePtr() noexcept {
  if constexpr (std::is_array_v<T>) {
    size_ = 0;
  }
}
 
template <typename T>
UniquePtr<T>::UniquePtr(element_type* value, Deallocator& deallocator)
    : Base(value), deallocator_(&deallocator) {
  static_assert(!is_unbounded_array_v<T>,
                "UniquePtr for unbounded array type must provide size");
  if constexpr (is_bounded_array_v<T>) {
    size_ = std::extent_v<T>;
  }
}
 
template <typename T>
UniquePtr<T>::UniquePtr(element_type* value,
                        size_t size,
                        Deallocator& deallocator)
    : Base(value), size_(size), deallocator_(&deallocator) {
  static_assert(
      is_unbounded_array_v<T>,
      "UniquePtr must not provide size unless type is an unbounded array");
}
 
template <typename T>
template <typename U, std::enable_if_t<std::is_assignable_v<T*&, U*>, int>>
constexpr UniquePtr<T>::operator UniquePtr<U>() && {
  Deallocator& deallocator = *deallocator_;
  return UniquePtr<U>(static_cast<U*>(Release()), deallocator);
}
 
template <typename T>
size_t UniquePtr<T>::size() const {
  static_assert(std::is_array_v<T>,
                "size() cannot be called with a non-array type");
  return size_;
}
 
template <typename T>
template <typename U, typename>
UniquePtr<T>& UniquePtr<T>::operator=(UniquePtr<U>&& other) noexcept {
  Reset();
  CopyFrom(other);
  other.Release();
  return *this;
}
 
template <typename T>
UniquePtr<T>& UniquePtr<T>::operator=(std::nullptr_t) noexcept {
  Reset();
  return *this;
}
 
template <typename T>
typename UniquePtr<T>::element_type* UniquePtr<T>::Release() noexcept {
  element_type* value = Base::Release();
  deallocator_ = nullptr;
  if constexpr (std::is_array_v<T>) {
    size_ = 0;
  }
  return value;
}
 
template <typename T>
void UniquePtr<T>::Reset() noexcept {
  if (*this == nullptr) {
    return;
  }
  if (!deallocator_->HasCapability(allocator::kSkipsDestroy)) {
    if constexpr (std::is_array_v<T>) {
      Base::Destroy(size_);
      size_ = 0;
    } else {
      Base::Destroy();
    }
  }
  Deallocator* deallocator = deallocator_;
  auto* ptr = const_cast<std::remove_const_t<element_type>*>(Release());
  deallocator->Deallocate(ptr);
}
 
template <typename T>
void UniquePtr<T>::Swap(UniquePtr<T>& other) {
  Base::Swap(other);
  if constexpr (std::is_array_v<T>) {
    std::swap(size_, other.size_);
  }
  std::swap(deallocator_, other.deallocator_);
}
 
template <typename T>
template <typename U, typename>
void UniquePtr<T>::CopyFrom(const UniquePtr<U>& other) {
  static_assert(std::is_array_v<T> == std::is_array_v<U>);
  Base::CopyFrom(other);
  if constexpr (std::is_array_v<T>) {
    size_ = other.size_;
  }
  deallocator_ = other.deallocator_;
}
 
}  // namespace pw