folly::detail::shared_ptr_internals Class Reference

#include <AtomicSharedPtr-detail.h>

Classes
struct	access_base
struct	access_counted_ptr_ptr
struct	access_refcount
struct	access_shared_ptr
struct	access_shared_ptr_ptr
struct	access_use_count
struct	access_weak_count
struct	Rob

Public Types
typedef std::__shared_count< std::_S_atomic >	shared_count
typedef std::_Sp_counted_base< std::_S_atomic >	counted_base
template<typename T >
using	CountedPtr = std::shared_ptr< T >

Static Public Member Functions
template<typename T , typename... Args>
static std::shared_ptr< T >	make_ptr (Args &&...args)
template<typename T >
static counted_base *	get_counted_base (const std::shared_ptr< T > &bar)
static void	inc_shared_count (counted_base *base, long count)
template<typename T >
static void	release_shared (counted_base *base, long count)
template<typename T >
static T *	get_shared_ptr (counted_base *base)
template<typename T >
static T *	release_ptr (std::shared_ptr< T > &p)
template<typename T >
static std::shared_ptr< T >	get_shared_ptr_from_counted_base (counted_base *base, bool inc=true)

Detailed Description

Definition at line 33 of file AtomicSharedPtr-detail.h.

Member Typedef Documentation

typedef std::_Sp_counted_base<std::_S_atomic> folly::detail::shared_ptr_internals::counted_base

Definition at line 40 of file AtomicSharedPtr-detail.h.

template<typename T >

using folly::detail::shared_ptr_internals::CountedPtr = std::shared_ptr<T>

Definition at line 42 of file AtomicSharedPtr-detail.h.

typedef std::__shared_count<std::_S_atomic> folly::detail::shared_ptr_internals::shared_count

Definition at line 39 of file AtomicSharedPtr-detail.h.

Member Function Documentation

template<typename T >

shared_ptr_internals::counted_base * folly::detail::shared_ptr_internals::get_counted_base ( const std::shared_ptr< T > &  bar )

inlinestatic

Definition at line 133 of file AtomicSharedPtr-detail.h.

References folly::detail::shared_ptr_internals::access_shared_ptr::fieldPtr, and ptr.

                                                                  {
  // reinterpret_pointer_cast<const void>
  // Not quite C++ legal, but explicit template instantiation access to
  // private members requires full type name (i.e. shared_ptr<const void>, not
  // shared_ptr<T>)
  const std::shared_ptr<const void>& ptr(
      reinterpret_cast<const std::shared_ptr<const void>&>(bar));
  return (ptr.*fieldPtr(access_shared_ptr{})).*fieldPtr(access_base{});
}

template<typename T >

T * folly::detail::shared_ptr_internals::get_shared_ptr ( counted_base *  base )

inlinestatic

Definition at line 171 of file AtomicSharedPtr-detail.h.

References folly::detail::shared_ptr_internals::access_shared_ptr::fieldPtr, ptr, and folly::T.

                                                                 {
  // See if this was a make_shared allocation
  auto inplace = base->_M_get_deleter(typeid(std::_Sp_make_shared_tag));
  if (inplace) {
    return (T*)inplace;
  }
  // Could also be a _Sp_counted_deleter, but the layout is the same
  using derived_type = std::_Sp_counted_ptr<const void*, std::_S_atomic>;
  auto ptr = reinterpret_cast<derived_type*>(base);
  return (T*)(ptr->*fieldPtr(access_counted_ptr_ptr{}));
}

template<typename T >

std::shared_ptr< T > folly::detail::shared_ptr_internals::get_shared_ptr_from_counted_base ( counted_base *  base, bool  inc = true  )

inlinestatic

Definition at line 195 of file AtomicSharedPtr-detail.h.

References folly::detail::shared_ptr_internals::access_shared_ptr::fieldPtr, inc_shared_count(), and folly::gen::move.

              {
  if (!base) {
    return nullptr;
  }
  std::shared_ptr<const void> newp;
  if (inc) {
    inc_shared_count(base, 1);
  }
  newp.*fieldPtr(access_shared_ptr_ptr{}) =
      get_shared_ptr<const void>(base); // _M_ptr
  (newp.*fieldPtr(access_refcount{})).*fieldPtr(access_base{}) = base;
  // reinterpret_pointer_cast<T>
  auto res = reinterpret_cast<std::shared_ptr<T>*>(&newp);
  return std::move(*res);
}

void folly::detail::shared_ptr_internals::inc_shared_count ( counted_base *  base, long  count  )

inlinestatic

Definition at line 143 of file AtomicSharedPtr-detail.h.

References folly::detail::shared_ptr_internals::access_shared_ptr::fieldPtr, and FOLLY_SAFE_CHECK.

Referenced by get_shared_ptr_from_counted_base().

                {
  // Check that we don't exceed the maximum number of atomic_shared_ptrs.
  // Consider setting EXTERNAL_COUNT lower if this CHECK is hit.
  FOLLY_SAFE_CHECK(
      base->_M_get_use_count() + count < INT_MAX, "atomic_shared_ptr overflow");
  __gnu_cxx::__atomic_add_dispatch(
      &(base->*fieldPtr(access_use_count{})), count);
}

template<typename T , typename... Args>

static std::shared_ptr<T> folly::detail::shared_ptr_internals::make_ptr ( Args &&...  args )

inlinestatic

Definition at line 36 of file AtomicSharedPtr-detail.h.

References testing::Args().

                                                   {
    return std::make_shared<T>(std::forward<Args...>(args...));
  }

template<typename T >

T * folly::detail::shared_ptr_internals::release_ptr ( std::shared_ptr< T > &  p )

inlinestatic

Definition at line 184 of file AtomicSharedPtr-detail.h.

References folly::detail::shared_ptr_internals::access_shared_ptr::fieldPtr, and ptr.

                                                               {
  auto res = p.get();
  std::shared_ptr<const void>& ptr(
      reinterpret_cast<std::shared_ptr<const void>&>(p));
  ptr.*fieldPtr(access_shared_ptr_ptr{}) = nullptr;
  (ptr.*fieldPtr(access_refcount{})).*fieldPtr(access_base{}) = nullptr;
  return res;
}

template<typename T >

void folly::detail::shared_ptr_internals::release_shared ( counted_base *  base, long  count  )

inlinestatic

Definition at line 155 of file AtomicSharedPtr-detail.h.

References folly::detail::shared_ptr_internals::access_shared_ptr::fieldPtr.

                {
  // If count == 1, this is equivalent to base->_M_release()
  if (__gnu_cxx::__exchange_and_add_dispatch(
          &(base->*fieldPtr(access_use_count{})), -count) == count) {
    base->_M_dispose();

    if (__gnu_cxx::__exchange_and_add_dispatch(
            &(base->*fieldPtr(access_weak_count{})), -1) == 1) {
      base->_M_destroy();
    }
  }
}

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/concurrency/detail/AtomicSharedPtr-detail.h