folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy > Class Template Reference

#include <Synchronized.h>

Public Types
using	MutexType = std::mutex

Public Member Functions
	~LockedPtrBase ()
	LockedPtrBase (LockedPtrBase &&rhs) noexcept
LockedPtrBase &	operator= (LockedPtrBase &&rhs) noexcept
template<typename LockPolicyType >
	LockedPtrBase (LockedPtrBase< SynchronizedType, std::mutex, LockPolicyType > &&other) noexcept
template<typename LockPolicyType >
LockedPtrBase &	operator= (LockedPtrBase< SynchronizedType, std::mutex, LockPolicyType > &&rhs) noexcept
template<typename LockPolicyLhs , typename LockPolicyRhs >
void	assignImpl (LockedPtrBase< SynchronizedType, std::mutex, LockPolicyLhs > &lhs, LockedPtrBase< SynchronizedType, std::mutex, LockPolicyRhs > &rhs) noexcept
std::unique_lock< std::mutex > &	getUniqueLock ()
void	unlock ()

Protected Types
using	UnlockerData = std::pair< std::unique_lock< std::mutex >, SynchronizedType * >

Protected Member Functions
	LockedPtrBase ()
	LockedPtrBase (SynchronizedType *parent)
UnlockerData	releaseLock ()
void	reacquireLock (UnlockerData &&data)

Static Protected Member Functions
static SynchronizedType *	getSynchronized (const UnlockerData &data)

Protected Attributes
std::unique_lock< std::mutex >	lock_
SynchronizedType *	parent_ = nullptr

Friends
class	folly::ScopedUnlocker< SynchronizedType, LockPolicy >
template<typename S , typename L >
class	folly::LockedPtr
template<typename S , typename M , typename L >
class	LockedPtrBase

Detailed Description

template<class SynchronizedType, class LockPolicy>
class folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >

LockedPtrBase specialization for use with std::mutex.

When std::mutex is used we use a std::unique_lock to hold the mutex. This makes it possible to use std::condition_variable with a Synchronized<T, std::mutex>.

Definition at line 1119 of file Synchronized.h.

Member Typedef Documentation

template<class SynchronizedType , class LockPolicy >

using folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::MutexType = std::mutex

Definition at line 1121 of file Synchronized.h.

template<class SynchronizedType , class LockPolicy >

using folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::UnlockerData = std::pair<std::unique_lock<std::mutex>, SynchronizedType*>

protected

Definition at line 1218 of file Synchronized.h.

Constructor & Destructor Documentation

template<class SynchronizedType , class LockPolicy >

folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::~LockedPtrBase ( )

inline

Destructor releases.

Definition at line 1135 of file Synchronized.h.

                   {
    // The std::unique_lock will automatically release the lock when it is
    // destroyed, so we don't need to do anything extra here.
  }

template<class SynchronizedType , class LockPolicy >

folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::LockedPtrBase ( LockedPtrBase< SynchronizedType, std::mutex, LockPolicy > &&  rhs )

inlinenoexcept

Definition at line 1140 of file Synchronized.h.

References folly::exchange(), folly::gen::move, and folly::detail::rhs.

      : lock_{std::move(rhs.lock_)}, parent_{exchange(rhs.parent_, nullptr)} {}

template<class SynchronizedType , class LockPolicy >

template<typename LockPolicyType >

folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::LockedPtrBase ( LockedPtrBase< SynchronizedType, std::mutex, LockPolicyType > &&  other )

inlinenoexcept

Templated move construct and assignment operators

These allow converting LockedPtr types that have the same unlocking policy to each other.

Definition at line 1154 of file Synchronized.h.

References folly::exchange(), and folly::gen::move.

      : lock_{std::move(other.lock_)},
        parent_{exchange(other.parent_, nullptr)} {}

template<class SynchronizedType , class LockPolicy >

folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::LockedPtrBase ( )

inlineprotected

Definition at line 1207 of file Synchronized.h.

{}

template<class SynchronizedType , class LockPolicy >

folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::LockedPtrBase ( SynchronizedType *  parent )

inlineexplicitprotected

Definition at line 1208 of file Synchronized.h.

References folly::lock(), and parent.

      : lock_{parent->mutex_, std::adopt_lock}, parent_{parent} {
    DCHECK(parent);
    if (!LockPolicy::lock(parent_->mutex_)) {
      parent_ = nullptr;
      lock_.release();
    }
  }

Member Function Documentation

template<class SynchronizedType , class LockPolicy >

template<typename LockPolicyLhs , typename LockPolicyRhs >

void folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::assignImpl ( LockedPtrBase< SynchronizedType, std::mutex, LockPolicyLhs > &  lhs, LockedPtrBase< SynchronizedType, std::mutex, LockPolicyRhs > &  rhs  )

inlinenoexcept

Implementation for the assignment operator

Definition at line 1170 of file Synchronized.h.

References folly::exchange(), folly::gen::move, and folly::detail::rhs.

                        {
    lhs.lock_ = std::move(rhs.lock_);
    lhs.parent_ = exchange(rhs.parent_, nullptr);
  }

template<class SynchronizedType , class LockPolicy >

static SynchronizedType* folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::getSynchronized ( const UnlockerData &  data )

inlinestaticprotected

Definition at line 1220 of file Synchronized.h.

                                                                     {
    return data.second;
  }

template<class SynchronizedType , class LockPolicy >

std::unique_lock<std::mutex>& folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::getUniqueLock ( )

inline

Get a reference to the std::unique_lock.

This is provided so that callers can use Synchronized<T, std::mutex> with a std::condition_variable.

While this API could be used to bypass the normal Synchronized APIs and manually interact with the underlying unique_lock, this is strongly discouraged.

Definition at line 1188 of file Synchronized.h.

                                            {
    return lock_;
  }

template<class SynchronizedType , class LockPolicy >

LockedPtrBase& folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::operator= ( LockedPtrBase< SynchronizedType, std::mutex, LockPolicy > &&  rhs )

inlinenoexcept

Definition at line 1142 of file Synchronized.h.

References folly::detail::rhs.

                                                         {
    assignImpl(*this, rhs);
    return *this;
  }

template<class SynchronizedType , class LockPolicy >

template<typename LockPolicyType >

LockedPtrBase& folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::operator= ( LockedPtrBase< SynchronizedType, std::mutex, LockPolicyType > &&  rhs )

inlinenoexcept

Definition at line 1159 of file Synchronized.h.

References folly::detail::rhs.

                        {
    assignImpl(*this, rhs);
    return *this;
  }

template<class SynchronizedType , class LockPolicy >

void folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::reacquireLock ( UnlockerData &&  data )

inlineprotected

Definition at line 1231 of file Synchronized.h.

References folly::data(), and folly::gen::move.

                                          {
    lock_ = std::move(data.first);
    lock_.lock();
    parent_ = data.second;
  }

template<class SynchronizedType , class LockPolicy >

UnlockerData folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::releaseLock ( )

inlineprotected

Definition at line 1224 of file Synchronized.h.

References folly::data(), and folly::gen::move.

                             {
    DCHECK(parent_ != nullptr);
    UnlockerData data(std::move(lock_), parent_);
    parent_ = nullptr;
    data.first.unlock();
    return data;
  }

template<class SynchronizedType , class LockPolicy >

void folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::unlock ( )

inline

Unlock the synchronized data.

The LockedPtr can no longer be dereferenced after unlock() has been called. isValid() will return false on an unlocked LockedPtr.

unlock() can only be called on a LockedPtr that is valid.

Definition at line 1200 of file Synchronized.h.

                {
    DCHECK(parent_ != nullptr);
    lock_.unlock();
    parent_ = nullptr;
  }

Friends And Related Function Documentation

template<class SynchronizedType , class LockPolicy >

template<typename S , typename L >

friend class folly::LockedPtr

friend

Friend all instantiations of LockedPtr and LockedPtrBase

Definition at line 1128 of file Synchronized.h.

template<class SynchronizedType , class LockPolicy >

friend class folly::ScopedUnlocker< SynchronizedType, LockPolicy >

friend

Definition at line 1122 of file Synchronized.h.

template<class SynchronizedType , class LockPolicy >

template<typename S , typename M , typename L >

friend class LockedPtrBase

friend

Definition at line 1130 of file Synchronized.h.

Member Data Documentation

template<class SynchronizedType , class LockPolicy >

std::unique_lock<std::mutex> folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::lock_

protected

Definition at line 1239 of file Synchronized.h.

template<class SynchronizedType , class LockPolicy >

SynchronizedType* folly::LockedPtrBase< SynchronizedType, std::mutex, LockPolicy >::parent_ = nullptr

protected

Definition at line 1240 of file Synchronized.h.

---

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

• proxygen/folly/folly/Synchronized.h