folly::LockedPtr< SynchronizedType, LockPolicy > Class Template Reference

#include <Synchronized.h>

Inheritance diagram for folly::LockedPtr< SynchronizedType, LockPolicy >:

Public Types
using	DataType = typename SynchronizedType::DataType
using	MutexType = typename SynchronizedType::MutexType
using	Synchronized = typename std::remove_const< SynchronizedType >::type
Public Types inherited from folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >
using	MutexType = SynchronizedType::MutexType

Public Member Functions
	LockedPtr ()
	LockedPtr (SynchronizedType *parent)
template<class Rep , class Period >
	LockedPtr (SynchronizedType *parent, const std::chrono::duration< Rep, Period > &timeout)
	LockedPtr (LockedPtr &&rhs) noexcept=default
template<typename LockPolicyType , EnableIfSameUnlockPolicy< LockPolicyType > * = nullptr>
	LockedPtr (LockedPtr< SynchronizedType, LockPolicyType > &&other) noexcept
LockedPtr &	operator= (LockedPtr &&rhs) noexcept=default
template<typename LockPolicyType , EnableIfSameUnlockPolicy< LockPolicyType > * = nullptr>
LockedPtr &	operator= (LockedPtr< SynchronizedType, LockPolicyType > &&other) noexcept
	LockedPtr (const LockedPtr &rhs)=delete
LockedPtr &	operator= (const LockedPtr &rhs)=delete
	~LockedPtr ()
bool	isNull () const
	operator bool () const
CDataType *	operator-> () const
CDataType &	operator* () const
ScopedUnlocker< SynchronizedType, LockPolicy >	scopedUnlock ()
template<typename SyncType = SynchronizedType, typename = typename std::enable_if< LockTraits<typename SyncType::MutexType>::is_upgrade>::type>
LockedPtr< SynchronizedType, LockPolicyFromUpgradeToExclusive >	moveFromUpgradeToWrite ()
template<typename SyncType = SynchronizedType, typename = typename std::enable_if< LockTraits<typename SyncType::MutexType>::is_upgrade>::type>
LockedPtr< SynchronizedType, LockPolicyFromExclusiveToUpgrade >	moveFromWriteToUpgrade ()
template<typename SyncType = SynchronizedType, typename = typename std::enable_if< LockTraits<typename SyncType::MutexType>::is_upgrade>::type>
LockedPtr< SynchronizedType, LockPolicyFromUpgradeToShared >	moveFromUpgradeToRead ()
template<typename SyncType = SynchronizedType, typename = typename std::enable_if< LockTraits<typename SyncType::MutexType>::is_upgrade>::type>
LockedPtr< SynchronizedType, LockPolicyFromExclusiveToShared >	moveFromWriteToRead ()
Public Member Functions inherited from folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >
	~LockedPtrBase ()
void	unlock ()

Private Types
using	Base = LockedPtrBase< SynchronizedType, typename SynchronizedType::MutexType, LockPolicy >
using	UnlockerData = typename Base::UnlockerData
using	CDataType = detail::SynchronizedDataType< SynchronizedType >
template<typename LockPolicyOther >
using	EnableIfSameUnlockPolicy = std::enable_if_t< std::is_same< typename LockPolicy::UnlockPolicy, typename LockPolicyOther::UnlockPolicy >::value >

Friends
template<typename SynchronizedTypeOther , typename LockPolicyOther >
class	LockedPtr
class	ScopedUnlocker< SynchronizedType, LockPolicy >

Additional Inherited Members
Protected Types inherited from folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >
using	UnlockerData = SynchronizedType *
Protected Member Functions inherited from folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >
	LockedPtrBase ()
	LockedPtrBase (SynchronizedType *parent)
	LockedPtrBase (SynchronizedType *parent, const std::chrono::duration< Rep, Period > &timeout)
	LockedPtrBase (LockedPtrBase &&rhs) noexcept
	LockedPtrBase (LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicyType > &&rhs) noexcept
LockedPtrBase &	operator= (LockedPtrBase &&rhs) noexcept
LockedPtrBase &	operator= (LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicyType > &&rhs) noexcept
void	assignImpl (LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicyLhs > &lhs, LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicyRhs > &rhs) noexcept
UnlockerData	releaseLock ()
void	reacquireLock (UnlockerData &&data)
Static Protected Member Functions inherited from folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >
static SynchronizedType *	getSynchronized (UnlockerData data)
Protected Attributes inherited from folly::LockedPtrBase< SynchronizedType, SynchronizedType::MutexType, LockPolicy >
SynchronizedType *	parent_

Detailed Description

template<class SynchronizedType, class LockPolicy>
class folly::LockedPtr< SynchronizedType, LockPolicy >

A LockedPtr keeps a Synchronized<T> object locked for the duration of LockedPtr's existence.

It provides access the datum's members directly by using operator->() and operator*().

The LockPolicy parameter controls whether or not the lock is acquired in exclusive or shared mode.

Definition at line 49 of file Synchronized.h.

Member Typedef Documentation

template<class SynchronizedType, class LockPolicy>

using folly::LockedPtr< SynchronizedType, LockPolicy >::Base = LockedPtrBase< SynchronizedType, typename SynchronizedType::MutexType, LockPolicy>

private

Definition at line 1295 of file Synchronized.h.

template<class SynchronizedType, class LockPolicy>

using folly::LockedPtr< SynchronizedType, LockPolicy >::CDataType = detail::SynchronizedDataType<SynchronizedType>

private

Definition at line 1298 of file Synchronized.h.

template<class SynchronizedType, class LockPolicy>

using folly::LockedPtr< SynchronizedType, LockPolicy >::DataType = typename SynchronizedType::DataType

Definition at line 1311 of file Synchronized.h.

template<class SynchronizedType, class LockPolicy>

template<typename LockPolicyOther >

using folly::LockedPtr< SynchronizedType, LockPolicy >::EnableIfSameUnlockPolicy = std::enable_if_t<std::is_same< typename LockPolicy::UnlockPolicy, typename LockPolicyOther::UnlockPolicy>::value>

private

Definition at line 1304 of file Synchronized.h.

template<class SynchronizedType, class LockPolicy>

using folly::LockedPtr< SynchronizedType, LockPolicy >::MutexType = typename SynchronizedType::MutexType

Definition at line 1312 of file Synchronized.h.

template<class SynchronizedType, class LockPolicy>

using folly::LockedPtr< SynchronizedType, LockPolicy >::Synchronized = typename std::remove_const<SynchronizedType>::type

Definition at line 1313 of file Synchronized.h.

template<class SynchronizedType, class LockPolicy>

using folly::LockedPtr< SynchronizedType, LockPolicy >::UnlockerData = typename Base::UnlockerData

private

Definition at line 1296 of file Synchronized.h.

Constructor & Destructor Documentation

template<class SynchronizedType, class LockPolicy>

folly::LockedPtr< SynchronizedType, LockPolicy >::LockedPtr ( )

inline

Creates an uninitialized LockedPtr.

Dereferencing an uninitialized LockedPtr is not allowed.

Definition at line 1321 of file Synchronized.h.

{}

template<class SynchronizedType, class LockPolicy>

folly::LockedPtr< SynchronizedType, LockPolicy >::LockedPtr ( SynchronizedType *  parent )

inlineexplicit

Takes a Synchronized<T> and locks it.

Definition at line 1326 of file Synchronized.h.

: Base(parent) {}

template<class SynchronizedType, class LockPolicy>

template<class Rep , class Period >

folly::LockedPtr< SynchronizedType, LockPolicy >::LockedPtr ( SynchronizedType *  parent, const std::chrono::duration< Rep, Period > &  timeout  )

inline

Takes a Synchronized<T> and attempts to lock it, within the specified timeout.

Blocks until the lock is acquired or until the specified timeout expires. If the timeout expired without acquiring the lock, the LockedPtr will be null, and LockedPtr::isNull() will return true.

Definition at line 1337 of file Synchronized.h.

References folly::pushmi::__adl::noexcept(), and folly::detail::rhs.

      : Base(parent, timeout) {}

template<class SynchronizedType, class LockPolicy>

folly::LockedPtr< SynchronizedType, LockPolicy >::LockedPtr ( LockedPtr< SynchronizedType, LockPolicy > &&  rhs )

defaultnoexcept

Move constructor.

template<class SynchronizedType, class LockPolicy>

template<typename LockPolicyType , EnableIfSameUnlockPolicy< LockPolicyType > * = nullptr>

folly::LockedPtr< SynchronizedType, LockPolicy >::LockedPtr ( LockedPtr< SynchronizedType, LockPolicyType > &&  other )

inlinenoexcept

Definition at line 1349 of file Synchronized.h.

References folly::gen::move, folly::pushmi::__adl::noexcept(), and folly::detail::rhs.

      : Base{std::move(other)} {}

template<class SynchronizedType, class LockPolicy>

folly::LockedPtr< SynchronizedType, LockPolicy >::LockedPtr ( const LockedPtr< SynchronizedType, LockPolicy > &  rhs )

delete

template<class SynchronizedType, class LockPolicy>

folly::LockedPtr< SynchronizedType, LockPolicy >::~LockedPtr ( )

inline

Destructor releases.

Definition at line 1374 of file Synchronized.h.

{}

Member Function Documentation

template<class SynchronizedType, class LockPolicy>

bool folly::LockedPtr< SynchronizedType, LockPolicy >::isNull ( ) const

inline

Check if this LockedPtr is uninitialized, or points to valid locked data.

This method can be used to check if a timed-acquire operation succeeded. If an acquire operation times out it will result in a null LockedPtr.

A LockedPtr is always either null, or holds a lock to valid data. Methods such as scopedUnlock() reset the LockedPtr to null for the duration of the unlock.

Definition at line 1386 of file Synchronized.h.

                      {
    return this->parent_ == nullptr;
  }

template<class SynchronizedType, class LockPolicy>

template<typename SyncType = SynchronizedType, typename = typename std::enable_if< LockTraits<typename SyncType::MutexType>::is_upgrade>::type>

LockedPtr<SynchronizedType, LockPolicyFromUpgradeToShared> folly::LockedPtr< SynchronizedType, LockPolicy >::moveFromUpgradeToRead ( )

inline

Move the locked ptr from an upgrade state to a shared state. The current lock is left in a null state.

Definition at line 1469 of file Synchronized.h.

References folly::exchange(), and type.

                          {
    return LockedPtr<SynchronizedType, LockPolicyFromUpgradeToShared>(
        exchange(this->parent_, nullptr));
  }

template<class SynchronizedType, class LockPolicy>

template<typename SyncType = SynchronizedType, typename = typename std::enable_if< LockTraits<typename SyncType::MutexType>::is_upgrade>::type>

LockedPtr<SynchronizedType, LockPolicyFromUpgradeToExclusive> folly::LockedPtr< SynchronizedType, LockPolicy >::moveFromUpgradeToWrite ( )

inline

Move the locked ptr from an upgrade state to an exclusive state. The current lock is left in a null state.

Definition at line 1441 of file Synchronized.h.

References folly::exchange(), and type.

                           {
    return LockedPtr<SynchronizedType, LockPolicyFromUpgradeToExclusive>(
        exchange(this->parent_, nullptr));
  }

template<class SynchronizedType, class LockPolicy>

template<typename SyncType = SynchronizedType, typename = typename std::enable_if< LockTraits<typename SyncType::MutexType>::is_upgrade>::type>

LockedPtr<SynchronizedType, LockPolicyFromExclusiveToShared> folly::LockedPtr< SynchronizedType, LockPolicy >::moveFromWriteToRead ( )

inline

Move the locked ptr from an exclusive state to a shared state. The current lock is left in a null state.

Definition at line 1483 of file Synchronized.h.

References testing::Args(), D, folly::exchange(), and M.

                        {
    return LockedPtr<SynchronizedType, LockPolicyFromExclusiveToShared>(
        exchange(this->parent_, nullptr));
  }

template<class SynchronizedType, class LockPolicy>

template<typename SyncType = SynchronizedType, typename = typename std::enable_if< LockTraits<typename SyncType::MutexType>::is_upgrade>::type>

LockedPtr<SynchronizedType, LockPolicyFromExclusiveToUpgrade> folly::LockedPtr< SynchronizedType, LockPolicy >::moveFromWriteToUpgrade ( )

inline

Move the locked ptr from an exclusive state to an upgrade state. The current lock is left in a null state.

Definition at line 1455 of file Synchronized.h.

References folly::exchange(), and type.

                           {
    return LockedPtr<SynchronizedType, LockPolicyFromExclusiveToUpgrade>(
        exchange(this->parent_, nullptr));
  }

template<class SynchronizedType, class LockPolicy>

folly::LockedPtr< SynchronizedType, LockPolicy >::operator bool ( ) const

inlineexplicit

Explicit boolean conversion.

Returns !isNull()

Definition at line 1395 of file Synchronized.h.

                                 {
    return this->parent_ != nullptr;
  }

template<class SynchronizedType, class LockPolicy>

CDataType& folly::LockedPtr< SynchronizedType, LockPolicy >::operator* ( ) const

inline

Access the locked data.

This method should only be used if the LockedPtr is valid.

Definition at line 1413 of file Synchronized.h.

                               {
    return this->parent_->datum_;
  }

template<class SynchronizedType, class LockPolicy>

CDataType* folly::LockedPtr< SynchronizedType, LockPolicy >::operator-> ( ) const

inline

Access the locked data.

This method should only be used if the LockedPtr is valid.

Definition at line 1404 of file Synchronized.h.

                                {
    return &this->parent_->datum_;
  }

template<class SynchronizedType, class LockPolicy>

LockedPtr& folly::LockedPtr< SynchronizedType, LockPolicy >::operator= ( LockedPtr< SynchronizedType, LockPolicy > &&  rhs )

defaultnoexcept

Move assignment operator.

template<class SynchronizedType, class LockPolicy>

template<typename LockPolicyType , EnableIfSameUnlockPolicy< LockPolicyType > * = nullptr>

LockedPtr& folly::LockedPtr< SynchronizedType, LockPolicy >::operator= ( LockedPtr< SynchronizedType, LockPolicyType > &&  other )

inlinenoexcept

Definition at line 1359 of file Synchronized.h.

References folly::gen::move, and folly::detail::rhs.

                                                                    {
    Base::operator=(std::move(other));
    return *this;
  }

template<class SynchronizedType, class LockPolicy>

LockedPtr& folly::LockedPtr< SynchronizedType, LockPolicy >::operator= ( const LockedPtr< SynchronizedType, LockPolicy > &  rhs )

delete

template<class SynchronizedType, class LockPolicy>

ScopedUnlocker<SynchronizedType, LockPolicy> folly::LockedPtr< SynchronizedType, LockPolicy >::scopedUnlock ( )

inline

Temporarily unlock the LockedPtr, and reset it to null.

Returns an helper object that will re-lock and restore the LockedPtr when the helper is destroyed. The LockedPtr may not be dereferenced for as long as this helper object exists.

Definition at line 1424 of file Synchronized.h.

References type.

                                                              {
    return ScopedUnlocker<SynchronizedType, LockPolicy>(this);
  }

Friends And Related Function Documentation

template<class SynchronizedType, class LockPolicy>

template<typename SynchronizedTypeOther , typename LockPolicyOther >

friend class LockedPtr

friend

Definition at line 1308 of file Synchronized.h.

template<class SynchronizedType, class LockPolicy>

friend class ScopedUnlocker< SynchronizedType, LockPolicy >

friend

Definition at line 1314 of file Synchronized.h.

---

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

• proxygen/folly/folly/Synchronized.h