+++ /dev/null
-#ifndef _OS_SMART_POINTER_H
-#define _OS_SMART_POINTER_H
-
-#include <sys/cdefs.h>
-#include <os/cpp_util.h>
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wc++11-extensions"
-
-#if __has_attribute(trivial_abi)
-# define OS_TRIVIAL_ABI __attribute__((trivial_abi))
-#else
-# error Smart pointers depend on trivial_abi attribute
-#endif
-
-#if !OS_HAS_RVALUE_REFERENCES
-# error Smart pointers depend on rvalue references
-#endif
-
-/* C++98 compatibility */
-#if !OS_HAS_NULLPTR && !defined(nullptr)
-# define nullptr NULL
-#endif
-
-#ifndef OSPTR_LOG
-# define OSPTR_LOG(x, ...) do {} while(0)
-#endif
-
-namespace os {
-static struct no_retain_t {} no_retain;
-
-template<class T, class Policy>
-class OS_TRIVIAL_ABI smart_ptr
-{
- template<class U, class OtherPolicy> friend class smart_ptr;
-
-public:
-
-/*
- * Default constructor, creates a null pointer
- */
- smart_ptr() : pointer(nullptr)
- {
- OSPTR_LOG("Default construct smart_ptr\n");
- }
-
-#if OS_HAS_NULLPTR
-/*
- * Construction from a nullptr
- */
- smart_ptr(os::nullptr_t) : pointer(nullptr)
- {
- OSPTR_LOG("Construct smart_ptr from null\n");
- }
-#endif
-
-/*
- * Construct from a raw pointer, taking a reference to the object
- */
- explicit smart_ptr(T *&p) : pointer(p)
- {
- OSPTR_LOG("Construct smart_ptr from raw %p\n", pointer);
- if (pointer != nullptr) {
- _retain(pointer);
- }
- }
-
-/*
- * Construct from a raw pointer, without bumping the refcount
- */
- explicit smart_ptr(T *&p, no_retain_t) : pointer(p)
- {
- OSPTR_LOG("Construct smart_ptr from raw %p no retain\n", pointer);
- }
-
-/*
- * Copy constructor from the same smart_ptr type
- */
- smart_ptr(smart_ptr const &rhs) : pointer(rhs.pointer)
- {
- OSPTR_LOG("Copy construct smart_ptr with %p\n", rhs.pointer);
- if (pointer != nullptr) {
- _retain(pointer);
- }
- }
-
-#if !LIBKERN_NO_MEMBER_TEMPLATES
-/*
- * Allows copy of a smart_ptr<T> from a smart_ptr<U>
- * if U is convertible to T. For example, if T is a base class of U
- */
- template<class U>
- smart_ptr(smart_ptr<U, Policy> const &rhs) : pointer(rhs.get())
- {
- OSPTR_LOG("Copy construct smart_ptr with compatible %p\n", rhs.pointer);
- if (pointer != nullptr) {
- _retain(pointer);
- }
- }
-#endif
-
-/*
- * Assign to an OSPointer from a raw pointer
- */
- smart_ptr &
- operator=(T *&rhs)
- {
- OSPTR_LOG("Assign smart_ptr with replacing %p with raw %p\n", pointer, rhs);
- smart_ptr(rhs).swap(*this);
- return *this;
- }
-
-#if OS_HAS_NULLPTR
-/*
- * Assign to an OSPointer from a null pointer
- */
- smart_ptr &
- operator=(os::nullptr_t)
- {
- OSPTR_LOG("Assign smart_ptr to null replacing %p\n", pointer);
- smart_ptr().swap(*this);
- return *this;
- }
-#endif
-
-/*
- * Assign to a smart_ptr from a smart_ptr of the same type
- */
- smart_ptr &
- operator=(smart_ptr &rhs)
- {
- OSPTR_LOG("Assign smart_ptr replacing %p with %p\n", pointer, rhs.pointer);
- smart_ptr(rhs).swap(*this);
- return *this;
- }
-
-#if !LIBKERN_NO_MEMBER_TEMPLATES
-/*
- * Allows assignment of a smart_ptr<T> from a smart_ptr<U>
- * if U is convertible to T. For example, if T is a base class of U.
- */
- template <class U>
- smart_ptr &
- operator=(smart_ptr<U, Policy> const &rhs)
- {
- OSPTR_LOG("Assign smart_ptr to compatible replacing %p with %p\n", pointer, rhs.pointer);
- smart_ptr(rhs.get()).swap(*this);
- return *this;
- }
-#endif
-
-/*
- * Move support
- */
-
-#if OS_HAS_RVALUE_REFERENCES
-/*
- * Move-construct from a different smart_ptr of the same pointer type
- */
- smart_ptr(smart_ptr &&rhs) : pointer(rhs.pointer)
- {
- OSPTR_LOG("Move construct smart_ptr with %p\n", rhs.pointer);
- rhs.pointer = nullptr;
- }
-
-/*
- * Move-construct from a raw pointer
- */
- smart_ptr(T *&&p) : pointer(p)
- {
- OSPTR_LOG("Move construct smart_ptr with %p\n", pointer);
- if (pointer != nullptr) {
- _retain(pointer);
- }
- p = nullptr;
- }
-
-/*
- * Move-construct from a raw pointer without bumping the refcount
- */
- smart_ptr(T *&&p, no_retain_t) : pointer(p)
- {
- OSPTR_LOG("Move construct smart_ptr with %p no retain\n", pointer);
- p = nullptr;
- }
-
-/*
- * Move-assign to a smart_ptr from a raw pointer
- */
- smart_ptr &
- operator=(T *&&rhs)
- {
- OSPTR_LOG("Move assign smart_ptr replacing %p with raw %p\n", pointer, rhs);
- smart_ptr(os::move(rhs)).swap(*this);
- rhs = nullptr;
- return *this;
- }
-
-/*
- * Move-assign from a different smart_ptr of the same type
- */
- smart_ptr &
- operator=(smart_ptr &&rhs)
- {
- OSPTR_LOG("Move assign smart_ptr replacing %p with %p\n", pointer, rhs.pointer);
- smart_ptr(os::move(rhs)).swap(*this);
- return *this;
- }
-
-/*
- * Move from a different smart_ptr with a compatible pointer type
- */
- template<class U>
- smart_ptr(smart_ptr<U, Policy> &&rhs) : pointer(rhs.pointer)
- {
- OSPTR_LOG("Move construct smart_ptr with compatible %p\n", rhs.pointer);
- rhs.pointer = nullptr;
- }
-
- template<class U>
- smart_ptr &
- operator=(smart_ptr<U, Policy> &&rhs)
- {
- OSPTR_LOG("Move assign smart_ptr replacing %p with compatible %p\n", pointer, rhs.pointer);
- smart_ptr(os::move(rhs)).swap(*this);
- return *this;
- }
-#endif
-
-/*
- * Destructor - decreases the object's reference count
- */
- ~smart_ptr()
- {
- OSPTR_LOG("Destroy smart_ptr with %p\n", pointer);
- if (pointer) {
- _release(pointer);
- }
- }
-
-/*
- * Create a new object of type T and wrap it in a smart_ptr. The object will have
- * a reference count of 1, so destruction of the smart_ptr will result in the
- * object being freed if the smart_ptr wasn't copied first.
- */
- static inline smart_ptr
- alloc()
- {
- return smart_ptr(_alloc(), no_retain);
- }
-
- void
- reset()
- {
- smart_ptr().swap(*this);
- }
-
- T *
- get() const
- {
- return pointer;
- }
-
- T **
- get_for_out_param()
- {
- reset();
- return &pointer;
- }
-
-/*
- * Take ownership of object from raw pointer
- */
- void
- attach(T *&p)
- {
- OSPTR_LOG("Attach smart_ptr with %p\n", p);
- smart_ptr(p, no_retain).swap(*this);
- }
-
- void
- attach(T *&&p)
- {
- OSPTR_LOG("Move attach smart_ptr with %p\n", p);
- smart_ptr(os::move(p), no_retain).swap(*this);
- }
-
-/* Return and drop ownership of pointer with NO release() */
- T *
- detach()
- {
- OSPTR_LOG("Detach smart_ptr with %p\n", pointer);
- T *ret = pointer;
- pointer = nullptr;
- return ret;
- }
-
- T *
- operator->() const
- {
- OSPTR_LOG("Dereference smart_ptr with %p\n", pointer);
- return pointer;
- }
-
- explicit
- operator bool() const
- {
- return pointer != nullptr;
- }
-
- inline void
- swap(smart_ptr &p)
- {
- T *temp = pointer;
- pointer = p.pointer;
- p.pointer = temp;
- }
-
-/* swap pointers to the same type but with different policies */
- template<class OtherPolicy>
- void
- swap(smart_ptr<T, OtherPolicy> &p)
- {
- if (p.pointer) {
- _retain(p.pointer);
- }
- if (pointer) {
- smart_ptr<T, OtherPolicy>::_retain(pointer);
- }
-
- T *temp = pointer;
- pointer = p.pointer;
- p.pointer = temp;
-
- if (p.pointer) {
- _release(p.pointer);
- }
- if (pointer) {
- smart_ptr<T, OtherPolicy>::_release(pointer);
- }
- }
-
- template<class U>
- smart_ptr<U, Policy>
- const_pointer_cast() const &
- {
- OSPTR_LOG("const_pointer_cast smart_ptr with %p\n", pointer);
- return smart_ptr<U, Policy>(const_cast<U *>(pointer));
- }
-
- template <class U>
- smart_ptr<U, Policy>
- const_pointer_cast() &&
- {
- OSPTR_LOG("const_pointer_cast move smart_ptr with %p\n", pointer);
- U *newPointer = const_cast<U *>(detach());
- return smart_ptr<U, Policy>(os::move(newPointer), no_retain);
- }
-
- template <class U>
- smart_ptr<U, Policy>
- static_pointer_cast() const &
- {
- OSPTR_LOG("static_pointer_cast smart_ptr with %p\n", pointer);
- return smart_ptr<U, Policy>(static_cast<U *>(pointer));
- }
-
- template <class U>
- smart_ptr<U, Policy>
- static_pointer_cast() &&
- {
- OSPTR_LOG("static_pointer_cast move smart_ptr with %p\n", pointer);
- return smart_ptr<U, Policy>(static_cast<U *>(detach()), no_retain);
- }
-
- template <class U>
- smart_ptr<U, Policy>
- dynamic_pointer_cast() const &
- {
- OSPTR_LOG("dynamic_pointer_cast smart_ptr with %p\n", pointer);
- return smart_ptr<U, Policy>(Policy::template dyn_cast<T, U>(pointer));
- }
-
- template <class U>
- smart_ptr<U, Policy>
- dynamic_pointer_cast() &&
- {
- OSPTR_LOG("dynamic_pointer_cast move smart_ptr with %p\n", pointer);
- U *newPointer = Policy::template dyn_cast<T, U>(pointer);
-
- if (newPointer != nullptr) {
- detach();
- } else {
- reset();
- }
- return smart_ptr<U, Policy>(os::move(newPointer), no_retain);
- }
-
-private:
- static inline void
- _retain(T *obj)
- {
- OSPTR_LOG(" %s with %p\n", __FUNCTION__, obj);
- Policy::retain(obj);
- }
-
- static inline void
- _release(T *obj)
- {
- OSPTR_LOG(" %s with %p\n", __FUNCTION__, obj);
- Policy::release(obj);
- }
-
- static inline T *
- _alloc()
- {
- OSPTR_LOG(" %s\n", __FUNCTION__);
- return Policy::template alloc<T>();
- }
-
- T *pointer;
-};
-
-/*
- * Comparison
- */
-
-template<class T, class Policy>
-inline bool
-operator==(smart_ptr<T, Policy> const &a, smart_ptr<T, Policy> const &b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class Policy>
-inline bool
-operator!=(smart_ptr<T, Policy> const &a, smart_ptr<T, Policy> const &b)
-{
- return a.get() != b.get();
-}
-
-template<class A, class A_policy, class B, class B_policy>
-inline bool
-operator==(smart_ptr<A, A_policy> const &a, smart_ptr<B, B_policy> const &b)
-{
- return a.get() == b.get();
-}
-
-template<class A, class A_policy, class B, class B_policy>
-inline bool
-operator!=(smart_ptr<A, A_policy> const &a, smart_ptr<B, B_policy> const &b)
-{
- return a.get() != b.get();
-}
-
-/*
- * Comparison with nullptr
- */
-
-#if OS_HAS_NULLPTR
-template<class T, class Policy>
-inline bool
-operator==(smart_ptr<T, Policy> const &p, os::nullptr_t)
-{
- return p.get() == nullptr;
-}
-
-template<class T, class Policy> inline bool
-operator==(os::nullptr_t, smart_ptr<T, Policy> const &p)
-{
- return p.get() == nullptr;
-}
-
-template<class T, class Policy>
-inline bool
-operator!=(smart_ptr<T, Policy> const &p, os::nullptr_t)
-{
- return p.get() != nullptr;
-}
-
-template<class T, class Policy>
-inline bool
-operator!=(os::nullptr_t, smart_ptr<T, Policy> const &p)
-{
- return p.get() != nullptr;
-}
-#endif
-
-/*
- * Comparison with raw pointer
- */
-
-template<class T, class Policy>
-inline bool
-operator==(smart_ptr<T, Policy> const &p, const os::remove_const_t<T> *other)
-{
- return p.get() == other;
-}
-
-template<class T, class Policy>
-inline bool
-operator==(const os::remove_const_t<T> *other, smart_ptr<T, Policy> const &p)
-{
- return other == p.get();
-}
-
-template<class T, class Policy>
-inline bool
-operator!=(smart_ptr<T, Policy> const &p, const os::remove_const_t<T> *other)
-{
- return p.get() != other;
-}
-
-template<class T, class Policy>
-inline bool
-operator!=(const os::remove_const_t<T> *other, smart_ptr<T, Policy> const &p)
-{
- return other != p.get();
-}
-};
-
-#pragma clang diagnostic pop
-#endif /* _OS_SMART_POINTER_H */
projects / apple / xnu.git / blobdiff