proxygen: folly::threadlocal_detail::ElementWrapper Struct Reference

#include <ThreadLocalDetail.h>

Public Types
using	DeleterFunType = void(void *, TLPDestructionMode)

Public Member Functions
bool	dispose (TLPDestructionMode mode)

void *	release ()

template<class Ptr >
void	set (Ptr p)

template<class Ptr , class Deleter >
void	set (Ptr p, const Deleter &d)

void	cleanup ()

Public Attributes
void *	ptr

union {
DeleterFunType * deleter1

std::function< DeleterFunType > * deleter2

};

bool	ownsDeleter

ThreadEntryNode	node

Detailed Description

POD wrapper around an element (a void*) and an associated deleter. This must be POD, as we memset() it to 0 and memcpy() it around.

Definition at line 118 of file ThreadLocalDetail.h.

Member Typedef Documentation

using folly::threadlocal_detail::ElementWrapper::DeleterFunType = void(void*, TLPDestructionMode)

Definition at line 119 of file ThreadLocalDetail.h.

Member Function Documentation

void folly::threadlocal_detail::ElementWrapper::cleanup ( )

inline

Definition at line 180 of file ThreadLocalDetail.h.

References ptr.

                  {
     if (ownsDeleter) {
       delete deleter2;
     }
     ptr = nullptr;
     deleter1 = nullptr;
     ownsDeleter = false;
   }

bool folly::threadlocal_detail::ElementWrapper::dispose ( TLPDestructionMode mode )

inline

Definition at line 121 of file ThreadLocalDetail.h.

References mode, and ptr.

                                         {
     if (ptr == nullptr) {
       return false;
     }
 
     DCHECK(deleter1 != nullptr);
     ownsDeleter ? (*deleter2)(ptr, mode) : (*deleter1)(ptr, mode);
     return true;
   }

void* folly::threadlocal_detail::ElementWrapper::release ( )

inline

Definition at line 131 of file ThreadLocalDetail.h.

References folly::ssl::cleanup(), and ptr.

Referenced by folly::ThreadLocalPtr< SubscriberMap >::release().

                   {
     auto retPtr = ptr;
 
     if (ptr != nullptr) {
       cleanup();
     }
 
     return retPtr;
   }

template<class Ptr >

void folly::threadlocal_detail::ElementWrapper::set ( Ptr p )

inline

Definition at line 142 of file ThreadLocalDetail.h.

References folly::gen::guard(), folly::makeGuard(), and ptr.

                   {
     auto guard = makeGuard([&] { delete p; });
     DCHECK(ptr == nullptr);
     DCHECK(deleter1 == nullptr);
 
     if (p) {
       node.initIfZero(true /*locked*/);
       ptr = p;
       deleter1 = [](void* pt, TLPDestructionMode) {
         delete static_cast<Ptr>(pt);
       };
       ownsDeleter = false;
       guard.dismiss();
     }
   }

template<class Ptr , class Deleter >

void folly::threadlocal_detail::ElementWrapper::set	(	Ptr	p,
		const Deleter &	d
	)

inline

Definition at line 159 of file ThreadLocalDetail.h.

References folly::gen::guard(), folly::makeGuard(), mode, ptr, and folly::THIS_THREAD.

                                     {
     auto guard = makeGuard([&] {
       if (p) {
         d(p, TLPDestructionMode::THIS_THREAD);
       }
     });
     DCHECK(ptr == nullptr);
     DCHECK(deleter2 == nullptr);
     if (p) {
       node.initIfZero(true /*locked*/);
       ptr = p;
       auto d2 = d; // gcc-4.8 doesn't decay types correctly in lambda captures
       deleter2 = new std::function<DeleterFunType>(
           [d2](void* pt, TLPDestructionMode mode) {
             d2(static_cast<Ptr>(pt), mode);
           });
       ownsDeleter = true;
       guard.dismiss();
     }
   }