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 <memory>
#include <utility>
 
namespace pw {
 
// Forward declaration.
class Deallocator;
 
namespace allocator::internal {
 
class BaseUniquePtr {
 protected:
  using Capability = ::pw::allocator::Capability;
 
  static bool HasCapability(Deallocator* deallocator, Capability capability);
  static void Deallocate(Deallocator* deallocator, void* ptr);
};
 
}  // namespace allocator::internal
 
template <typename T>
class UniquePtr : public allocator::internal::BaseUniquePtr {
 public:
  using Base = ::pw::allocator::internal::BaseUniquePtr;
 
  constexpr UniquePtr() : value_(nullptr), deallocator_(nullptr) {}
 
  constexpr UniquePtr(std::nullptr_t) : UniquePtr() {}
 
  template <typename U>
  UniquePtr(UniquePtr<U>&& other) noexcept
      : value_(other.value_), deallocator_(other.deallocator_) {
    static_assert(
        std::is_assignable_v<T*&, U*>,
        "Attempted to construct a UniquePtr<T> from a UniquePtr<U> where "
        "U* is not assignable to T*.");
    other.Release();
  }
 
  // Move-only. These are needed since the templated move-contructor and
  // move-assignment operator do not exactly match the signature of the default
  // move-contructor and move-assignment operator, and thus do not implicitly
  // delete the copy-contructor and copy-assignment operator.
  UniquePtr(const UniquePtr&) = delete;
  UniquePtr& operator=(const UniquePtr&) = delete;
 
  template <typename U>
  UniquePtr& operator=(UniquePtr<U>&& other) noexcept {
    static_assert(std::is_assignable_v<T*&, U*>,
                  "Attempted to assign a UniquePtr<U> to a UniquePtr<T> where "
                  "U* is not assignable to T*.");
    Reset();
    value_ = other.value_;
    deallocator_ = other.deallocator_;
    other.Release();
    return *this;
  }
 
  UniquePtr& operator=(std::nullptr_t) {
    Reset();
    return *this;
  }
 
  ~UniquePtr() { Reset(); }
 
  Deallocator* deallocator() const { return deallocator_; }
 
  T* Release() {
    T* value = value_;
    value_ = nullptr;
    deallocator_ = nullptr;
    return value;
  }
 
  void Reset() {
    if (value_ == nullptr) {
      return;
    }
    if (!Base::HasCapability(deallocator_, Capability::kSkipsDestroy)) {
      std::destroy_at(value_);
    }
    Base::Deallocate(deallocator_, value_);
    Release();
  }
 
  explicit operator bool() const = delete;
 
  bool operator==(std::nullptr_t) const { return value_ == nullptr; }
 
  bool operator!=(std::nullptr_t) const { return value_ != nullptr; }
 
  T* get() { return value_; }
  const T* get() const { return value_; }
 
  T* operator->() { return value_; }
  const T* operator->() const { return value_; }
 
  T& operator*() { return *value_; }
  const T& operator*() const { return *value_; }
 
 private:
  T* value_;
 
  Deallocator* deallocator_;
 
  template <typename U>
  friend class UniquePtr;
 
  class PrivateConstructorType {};
  static constexpr PrivateConstructorType kPrivateConstructor{};
 
 public:
  UniquePtr(PrivateConstructorType, T* value, Deallocator* deallocator)
      : value_(value), deallocator_(deallocator) {}
 
  // Allow construction with ``kPrivateConstructor`` to the implementation
  // of ``MakeUnique``.
  friend class Deallocator;
};
 
namespace allocator {
 
// Alias for module consumers using the older name for the above type.
template <typename T>
using UniquePtr = ::pw::UniquePtr<T>;
 
}  // namespace allocator
}  // namespace pw