shared_ptr.h

// Copyright 2025 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 "pw_allocator/config.h"
 
// TODO(b/402489948): Remove when portable atomics are provided by `pw_atomic`.
#if PW_ALLOCATOR_HAS_ATOMICS
 
#include <cstddef>
#include <cstdint>
#include <utility>
 
#include "pw_allocator/deallocator.h"
#include "pw_allocator/internal/control_block.h"
#include "pw_allocator/internal/managed_ptr.h"
#include "pw_allocator/layout.h"
#include "pw_allocator/unique_ptr.h"
 
namespace pw {
 
 
// Forward declarations.
template <typename T>
class SharedPtr;
 
template <typename To, typename From>
constexpr SharedPtr<To> static_pointer_cast(const SharedPtr<From>& p) noexcept;
 
template <typename To, typename From>
constexpr SharedPtr<To> const_pointer_cast(const SharedPtr<From>& p) noexcept;
 
template <typename T>
class WeakPtr;
 
template <typename T>
class SharedPtr final : public ::pw::allocator::internal::ManagedPtr<T> {
 private:
  using Base = ::pw::allocator::internal::ManagedPtr<T>;
  using ControlBlock = ::pw::allocator::internal::ControlBlock;
  using ControlBlockHandle = ::pw::allocator::internal::ControlBlockHandle;
 
 public:
  using element_type = typename Base::element_type;
  using weak_type = WeakPtr<T>;
 
  ~SharedPtr() { reset(); }
 
  template <typename... Args>
  static SharedPtr Create(Allocator* allocator, Args&&... args);
 
  static SharedPtr Create(Allocator* allocator, size_t count, size_t alignment);
 
  constexpr SharedPtr() noexcept = default;
 
  constexpr SharedPtr(element_type* value, ControlBlock* control_block)
      : Base(value), control_block_(control_block) {}
 
  constexpr SharedPtr(std::nullptr_t) noexcept : SharedPtr() {}
 
  constexpr SharedPtr(const SharedPtr& other) noexcept : SharedPtr() {
    *this = other;
  }
 
  template <typename U,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  constexpr SharedPtr(const SharedPtr<U>& other) noexcept : SharedPtr() {
    *this = other;
  }
 
  template <typename U,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  SharedPtr(SharedPtr<U>&& other) noexcept : SharedPtr() {
    *this = std::move(other);
  }
 
  SharedPtr(UniquePtr<T>& owned) noexcept;
 
  constexpr SharedPtr& operator=(const SharedPtr& other) noexcept {
    operator= <T>(other);
    return *this;
  }
 
  template <typename U,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  constexpr SharedPtr& operator=(const SharedPtr<U>& other) noexcept;
 
  template <typename U,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  SharedPtr& operator=(SharedPtr<U>&& other) noexcept;
 
  SharedPtr& operator=(std::nullptr_t) noexcept;
 
  // Conversions
 
  template <typename U>
  constexpr explicit operator SharedPtr<U>() const {
    return static_pointer_cast<U>(*this);
  }
 
  template <typename To, typename From>
  friend constexpr SharedPtr<To> static_pointer_cast(
      const SharedPtr<From>& p) noexcept;
 
  template <typename To, typename From>
  friend constexpr SharedPtr<To> const_pointer_cast(
      const SharedPtr<From>& p) noexcept;
 
  // Comparisons
 
  [[nodiscard]] friend constexpr bool operator==(const SharedPtr& lhs,
                                                 std::nullptr_t) {
    return lhs.Equals(nullptr);
  }
  [[nodiscard]] friend constexpr bool operator==(std::nullptr_t,
                                                 const SharedPtr& rhs) {
    return rhs.Equals(nullptr);
  }
  [[nodiscard]] friend constexpr bool operator==(const SharedPtr& lhs,
                                                 const SharedPtr& rhs) {
    return lhs.Equals(rhs) && lhs.control_block_ == rhs.control_block_;
  }
 
  [[nodiscard]] friend constexpr bool operator!=(const SharedPtr& lhs,
                                                 std::nullptr_t) {
    return !lhs.Equals(nullptr);
  }
  [[nodiscard]] friend constexpr bool operator!=(std::nullptr_t,
                                                 const SharedPtr& rhs) {
    return !rhs.Equals(nullptr);
  }
  [[nodiscard]] friend constexpr bool operator!=(const SharedPtr& lhs,
                                                 const SharedPtr& rhs) {
    return !(lhs == rhs);
  }
 
  // Accessors
 
  constexpr size_t size() const {
    static_assert(std::is_array_v<T>,
                  "size() cannot be called on non-array types");
    return control_block_ == nullptr
               ? 0
               : (control_block_->size() / sizeof(element_type));
  }
 
  constexpr int32_t use_count() const {
    return control_block_ == nullptr ? 0 : control_block_->num_shared();
  }
 
  template <typename PtrType>
  bool owner_before(const PtrType& other) const noexcept {
    return std::less{}(control_block_, other.control_block_);
  }
 
  // Mutators
 
  void reset() noexcept;
 
  void swap(SharedPtr& other) noexcept;
 
  Allocator* allocator() const {
    return control_block_ == nullptr ? nullptr : control_block_->allocator();
  }
 
  ControlBlock* GetControlBlock(const ControlBlockHandle&) const {
    return control_block_;
  }
 
 private:
  using Layout = allocator::Layout;
 
  // Allow other SharedPtrs and WeakPtrs to access control blocks directly.
  template <typename>
  friend class SharedPtr;
 
  template <typename>
  friend class WeakPtr;
 
  template <typename U,
            typename = std::enable_if_t<std::is_assignable_v<T*&, U*>>>
  void CopyFrom(const SharedPtr<U>& other);
 
  void Release();
 
  template <typename U>
  constexpr void CheckArrayTypes();
 
  ControlBlock* control_block_ = nullptr;
};
 
 
// Template method implementations.
 
template <typename T>
SharedPtr<T>::SharedPtr(UniquePtr<T>& owned) noexcept {
  size_t size = sizeof(element_type);
  if constexpr (std::is_array_v<T>) {
    size *= owned.size();
  }
 
  // Create the shared pointer's control block using the restricted method.
  const auto& handle = ControlBlockHandle::GetInstance_DO_NOT_USE();
  control_block_ =
      ControlBlock::Create(handle, owned.deallocator(), owned.get(), size);
 
  if (control_block_ != nullptr) {
    Base::CopyFrom(owned);
    owned.Release();
  }
}
 
template <typename T>
template <typename... Args>
SharedPtr<T> SharedPtr<T>::Create(Allocator* allocator, Args&&... args) {
  static_assert(!std::is_array_v<T>);
 
  // Create the shared pointer's control block using the restricted method.
  const auto& handle = ControlBlockHandle::GetInstance_DO_NOT_USE();
  auto* control_block =
      ControlBlock::Create(handle, allocator, Layout::Of<T>());
 
  if (control_block == nullptr) {
    return nullptr;
  }
  auto* t = new (control_block->data()) T(std::forward<Args>(args)...);
  return SharedPtr<T>(t, control_block);
}
 
template <typename T>
SharedPtr<T> SharedPtr<T>::Create(Allocator* allocator,
                                  size_t count,
                                  size_t alignment) {
  static_assert(allocator::internal::is_unbounded_array_v<T>);
  Layout layout = Layout::Of<T>(count).Align(alignment);
 
  // Create the shared pointer's control block using the restricted method.
  const auto& handle = ControlBlockHandle::GetInstance_DO_NOT_USE();
  auto* control_block = ControlBlock::Create(handle, allocator, layout);
 
  if (control_block == nullptr) {
    return nullptr;
  }
  auto* t = new (control_block->data()) element_type[count];
  return SharedPtr<T>(t, control_block);
}
 
template <typename T>
template <typename U, typename>
constexpr SharedPtr<T>& SharedPtr<T>::operator=(
    const SharedPtr<U>& other) noexcept {
  CheckArrayTypes<U>();
  reset();
  CopyFrom(other);
  if (control_block_ != nullptr) {
    control_block_->IncrementShared();
  }
  return *this;
}
 
template <typename T>
template <typename U, typename>
SharedPtr<T>& SharedPtr<T>::operator=(SharedPtr<U>&& other) noexcept {
  CheckArrayTypes<U>();
  reset();
  CopyFrom(other);
  other.Release();
  return *this;
}
 
template <typename T>
SharedPtr<T>& SharedPtr<T>::operator=(std::nullptr_t) noexcept {
  reset();
  return *this;
}
 
template <typename To, typename From>
constexpr SharedPtr<To> static_pointer_cast(const SharedPtr<From>& p) noexcept {
  using PtrType = typename SharedPtr<To>::element_type*;
  if (p.control_block_ != nullptr) {
    p.control_block_->IncrementShared();
  }
  return SharedPtr<To>{static_cast<PtrType>(p.get()), p.control_block_};
}
 
template <typename To, typename From>
constexpr SharedPtr<To> const_pointer_cast(const SharedPtr<From>& p) noexcept {
  using PtrType = typename SharedPtr<To>::element_type*;
  if (p.control_block_ != nullptr) {
    p.control_block_->IncrementShared();
  }
  return SharedPtr<To>{const_cast<PtrType>(p.get()), p.control_block_};
}
 
template <typename T>
void SharedPtr<T>::reset() noexcept {
  if (*this == nullptr) {
    return;
  }
  auto action = control_block_->DecrementShared();
  if (action == ControlBlock::Action::kNone) {
    // Other `SharedPtr`s associated with this control block remain.
    Release();
    return;
  }
 
  // This was the last `SharedPtr` associated with this control block.
  Allocator* allocator = control_block_->allocator();
  if (!Base::HasCapability(allocator, allocator::kSkipsDestroy)) {
    if constexpr (std::is_array_v<T>) {
      Base::Destroy(size());
    } else {
      Base::Destroy();
    }
  }
 
  if (action == ControlBlock::Action::kExpire) {
    // Keep the control block. Trying to promote any of the remaining
    // `WeakPtr`s will fail.
    Base::Resize(allocator, control_block_, sizeof(ControlBlock));
  } else {
    // No `WeakPtr`s remain, and all of the memory can be freed.
    std::destroy_at(control_block_);
    Base::Deallocate(allocator, control_block_);
  }
 
  Release();
}
 
template <typename T>
void SharedPtr<T>::swap(SharedPtr<T>& other) noexcept {
  Base::Swap(other);
  std::swap(control_block_, other.control_block_);
}
 
template <typename T>
template <typename U, typename>
void SharedPtr<T>::CopyFrom(const SharedPtr<U>& other) {
  CheckArrayTypes<U>();
  Base::CopyFrom(other);
  control_block_ = other.control_block_;
}
 
template <typename T>
void SharedPtr<T>::Release() {
  Base::Release();
  control_block_ = nullptr;
}
 
template <typename T>
template <typename U>
constexpr void SharedPtr<T>::CheckArrayTypes() {
  if constexpr (std::is_array_v<T>) {
    static_assert(std::is_array_v<U>,
                  "non-array type used with SharedPtr<T[]>");
  } else {
    static_assert(!std::is_array_v<U>, "array type used with SharedPtr<T>");
  }
}
 
}  // namespace pw
 
// TODO(b/402489948): Remove when portable atomics are provided by `pw_atomic`.
#endif  // PW_ALLOCATOR_HAS_ATOMICS