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, Args &&... args)
template<typename... Args, std::invocable< const Value &, Args... > F>
decltype(auto)	with_lock (F &&f, Args &&... args) const

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/3]

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>
requires ( std::is_constructible_v<Value, Args...> )

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

inline

Definition at line 37 of file SynchronizedValue.h.

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

SynchronizedValue() [2/3]

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() [3/3]

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;
    }

with_lock() [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>
requires ( !std::is_invocable_v<F, const Value&, Args...> )

decltype(auto) Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::with_lock ( F && f, Args &&... args )

inline

Definition at line 77 of file SynchronizedValue.h.

                                                        {
      WriteLock _{ m_mtx };
      return std::invoke( std::forward<F>( f ), m_obj, std::forward<Args>( args )... );
    }

with_lock() [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, std::invocable< const Value &, Args... > F>

decltype(auto) Gaudi::cxx::SynchronizedValue< Value, Mutex, ReadLock, WriteLock >::with_lock ( F && f, Args &&... args ) const

inline

Definition at line 83 of file SynchronizedValue.h.

                                                              {
      ReadLock _{ m_mtx };
      return std::invoke( std::forward<F>( f ), m_obj, std::forward<Args>( args )... );
    }

Member Data Documentation

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