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/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 {
    if constexpr (std::is_array_v<T>) {
      size_ = 0;
    }
  }
 
  // Not copyable.
  UniquePtr(const UniquePtr&) = delete;
  UniquePtr& operator=(const UniquePtr&) = delete;
 
  constexpr UniquePtr(std::nullptr_t) noexcept : UniquePtr() {}
 
  UniquePtr(element_type* value, Deallocator& deallocator)
      : Base(value), deallocator_(&deallocator) {
    static_assert(!allocator::internal::is_unbounded_array_v<T>,
                  "UniquePtr for unbounded array type must provide size");
    if constexpr (allocator::internal::is_bounded_array_v<T>) {
      size_ = std::extent_v<T>;
    }
  }
 
  UniquePtr(element_type* value, size_t size, Deallocator& deallocator)
      : Base(value), size_(size), deallocator_(&deallocator) {
    static_assert(
        allocator::internal::is_unbounded_array_v<T>,
        "UniquePtr must not provide size unless type is an unbounded array");
  }
 
  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,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  constexpr explicit operator UniquePtr<U>() && {
    Deallocator& deallocator = *deallocator_;
    return UniquePtr<U>(static_cast<U*>(Release()), deallocator);
  }
 
  [[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 {
    static_assert(std::is_array_v<T>,
                  "size() cannot be called with a non-array type");
    return size_;
  }
 
  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;
};
 
namespace allocator {
 
// Alias for module consumers using the older name for the above type.
template <typename T>
using UniquePtr = PW_ALLOCATOR_DEPRECATED ::pw::UniquePtr<T>;
 
}  // namespace allocator
 
 
// Template method implementations.
 
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 (!Base::HasCapability(deallocator_, 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());
  Base::Deallocate(deallocator, 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