Fast RTPS  Version 2.14.1
Fast RTPS
Loading...
Searching...
No Matches
shared_lock< Mutex > Class Template Reference

#include <shared_mutex.hpp>

Public Types

typedef Mutex mutex_type
 

Public Member Functions

 shared_lock ()
 
 shared_lock (mutex_type &m)
 
 shared_lock (mutex_type &m, std::defer_lock_t)
 
 shared_lock (mutex_type &m, std::try_to_lock_t)
 
 shared_lock (mutex_type &m, std::adopt_lock_t)
 
template<class Clock , class Duration >
 shared_lock (mutex_type &m, const std::chrono::time_point< Clock, Duration > &abs_time)
 
template<class Rep , class Period >
 shared_lock (mutex_type &m, const std::chrono::duration< Rep, Period > &rel_time)
 
 ~shared_lock ()
 
 shared_lock (shared_lock const &)=delete
 
shared_lockoperator= (shared_lock const &)=delete
 
 shared_lock (shared_lock &&sl)
 
shared_lockoperator= (shared_lock &&sl)
 
 shared_lock (std::unique_lock< mutex_type > &&ul)
 
void lock ()
 
bool try_lock ()
 
template<class Rep , class Period >
bool try_lock_for (const std::chrono::duration< Rep, Period > &rel_time)
 
template<class Clock , class Duration >
bool try_lock_until (const std::chrono::time_point< Clock, Duration > &abs_time)
 
void unlock ()
 
void swap (shared_lock &&u)
 
mutex_typerelease ()
 
bool owns_lock () const
 
 operator int __nat::* () const
 
mutex_typemutex () const
 

Member Typedef Documentation

◆ mutex_type

template<class Mutex >
typedef Mutex mutex_type

Constructor & Destructor Documentation

◆ shared_lock() [1/10]

template<class Mutex >
shared_lock ( )
inline

◆ shared_lock() [2/10]

template<class Mutex >
shared_lock ( mutex_type m)
inlineexplicit

◆ shared_lock() [3/10]

template<class Mutex >
shared_lock ( mutex_type m,
std::defer_lock_t   
)
inline

◆ shared_lock() [4/10]

template<class Mutex >
shared_lock ( mutex_type m,
std::try_to_lock_t   
)
inline

◆ shared_lock() [5/10]

template<class Mutex >
shared_lock ( mutex_type m,
std::adopt_lock_t   
)
inline

◆ shared_lock() [6/10]

template<class Mutex >
template<class Clock , class Duration >
shared_lock ( mutex_type m,
const std::chrono::time_point< Clock, Duration > &  abs_time 
)
inline

◆ shared_lock() [7/10]

template<class Mutex >
template<class Rep , class Period >
shared_lock ( mutex_type m,
const std::chrono::duration< Rep, Period > &  rel_time 
)
inline

◆ ~shared_lock()

template<class Mutex >
~shared_lock ( )
inline

◆ shared_lock() [8/10]

template<class Mutex >
shared_lock ( shared_lock< Mutex > const &  )
delete

◆ shared_lock() [9/10]

template<class Mutex >
shared_lock ( shared_lock< Mutex > &&  sl)
inline

◆ shared_lock() [10/10]

template<class Mutex >
shared_lock ( std::unique_lock< mutex_type > &&  ul)
inlineexplicit

Member Function Documentation

◆ lock()

template<class Mutex >
void lock ( )

◆ mutex()

template<class Mutex >
mutex_type * mutex ( ) const
inline

◆ operator int __nat::*()

template<class Mutex >
operator int __nat::* ( ) const
inline

◆ operator=() [1/2]

template<class Mutex >
shared_lock & operator= ( shared_lock< Mutex > &&  sl)
inline

◆ operator=() [2/2]

template<class Mutex >
shared_lock & operator= ( shared_lock< Mutex > const &  )
delete

◆ owns_lock()

template<class Mutex >
bool owns_lock ( ) const
inline

◆ release()

template<class Mutex >
mutex_type * release ( )
inline

◆ swap()

template<class Mutex >
void swap ( shared_lock< Mutex > &&  u)
inline

◆ try_lock()

template<class Mutex >
bool try_lock ( )

◆ try_lock_for()

template<class Mutex >
template<class Rep , class Period >
bool try_lock_for ( const std::chrono::duration< Rep, Period > &  rel_time)
inline

◆ try_lock_until()

template<class Mutex >
template<class Clock , class Duration >
bool try_lock_until ( const std::chrono::time_point< Clock, Duration > &  abs_time)

◆ unlock()

template<class Mutex >
void unlock ( )

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