Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock > Class Template Reference

#include </builds/gaudi/Gaudi/GaudiKernel/include/Gaudi/cxx/SynchronizedValue.h>

Collaboration diagram for Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >:

Public Member Functions
template<typename... Args>
	requires (std::is_constructible_v< Value, Args... >) SynchronizedValue(Args &&... args)
	SynchronizedValue (const SynchronizedValue &rhs)
SynchronizedValue &	operator= (const SynchronizedValue &rhs)
	SynchronizedValue (SynchronizedValue &&rhs)
SynchronizedValue &	operator= (SynchronizedValue &&rhs)
template<typename... Args, std::invocable< Value &, Args... > F>
	requires (!std::is_invocable_v< F, const Value &, Args... >) decltype(auto) with_lock(F &&f
return	std::invoke (std::forward< F >(f), m_obj, std::forward< Args >(args)...)

Public Attributes
Args &&	args

Private Attributes
Value	m_obj
Mutex	m_mtx

Detailed Description

template<typename Value, typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>
class Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >

Definition at line 29 of file SynchronizedValue.h.

Constructor & Destructor Documentation

SynchronizedValue() [1/2]

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::SynchronizedValue ( const SynchronizedValue< Value, Mutex, ReadLock, WriteLock > &  rhs )

inline

Definition at line 39 of file SynchronizedValue.h.

                                                      {
      static_assert( std::is_default_constructible_v<Value> ); // bound to hold, as otherwise we wouldn't get this
                                                               // far... so for 'documnentation purpose' really (C++20:
                                                               // turn into a `requires` clause )...
      static_assert( std::is_copy_assignable_v<Value> );
      auto lock = std::scoped_lock{ rhs.m_mtx, m_mtx };
      m_obj     = rhs.m_obj;
    }

SynchronizedValue() [2/2]

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::SynchronizedValue ( SynchronizedValue< Value, Mutex, ReadLock, WriteLock > &&  rhs )

inline

Definition at line 57 of file SynchronizedValue.h.

                                                 {
      static_assert( std::is_default_constructible_v<Value> ); // bound to hold, as otherwise we wouldn't get this
                                                               // far... so for 'documnentation purpose' really (C++20:
                                                               // turn into a `requires` clause )...
      static_assert( std::is_move_assignable_v<Value> );
      auto lock = std::scoped_lock{ rhs.m_mtx, m_mtx };
      m_obj     = std::move( rhs.m_obj );
    }

Member Function Documentation

operator=() [1/2]

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

SynchronizedValue& Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::operator= ( const SynchronizedValue< Value, Mutex, ReadLock, WriteLock > &  rhs )

inline

Definition at line 48 of file SynchronizedValue.h.

                                                                 {
      static_assert( std::is_copy_assignable_v<Value> );
      if ( this != &rhs ) {
        auto lock = std::scoped_lock{ rhs.m_mtx, m_mtx };
        m_obj     = rhs.m_obj;
      }
      return *this;
    }

operator=() [2/2]

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

SynchronizedValue& Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::operator= ( SynchronizedValue< Value, Mutex, ReadLock, WriteLock > &&  rhs )

inline

Definition at line 66 of file SynchronizedValue.h.

                                                            {
      static_assert( std::is_move_assignable_v<Value> );
      if ( this != &rhs ) {
        auto lock = std::scoped_lock{ rhs.m_mtx, m_mtx };
        m_obj     = std::move( rhs.m_obj );
      }
      return *this;
    }

requires() [1/2]

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

template<typename... Args, std::invocable< Value &, Args... > F>

Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::requires

(

!std::is_invocable_v< F, const Value &, Args... >

)

&&

requires() [2/2]

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

template<typename... Args>

Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::requires ( std::is_constructible_v< Value, Args... >  ) &&

inline

Definition at line 36 of file SynchronizedValue.h.

                                        : m_obj{ std::forward<Args>( args )... } {}

std::invoke()

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

return Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::std::invoke	(	std::forward< F >	f,
		m_obj	,
		std::forward< Args >(args)	...
	)

Member Data Documentation

args

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

Args&& Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::args

Initial value:

{
      WriteLock _{ m_mtx }

Definition at line 77 of file SynchronizedValue.h.

m_mtx

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

Mutex Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::m_mtx

mutableprivate

Definition at line 32 of file SynchronizedValue.h.

m_obj

template<typename Value , typename Mutex = std::mutex, typename ReadLock = std::conditional_t<std::is_same_v<std::shared_mutex, Mutex>, std::shared_lock<Mutex>, std::lock_guard<Mutex>>, typename WriteLock = std::lock_guard<Mutex>>

Value Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::m_obj

private

Definition at line 31 of file SynchronizedValue.h.

---

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

• GaudiKernel/include/Gaudi/cxx/SynchronizedValue.h