CounterHolder< BASE > Class Template Reference

#include <GaudiKernel/CounterHolder.h>

Inheritance diagram for CounterHolder< BASE >:

Collaboration diagram for CounterHolder< BASE >:

Public Member Functions
void	declareCounter (std::string tag, Gaudi::Accumulators::PrintableCounter &r)
const Gaudi::Accumulators::PrintableCounter *	findCounter (std::string_view tag) const
template<typename Callable >
void	forEachCounter (Callable &&f) const
int	nCounters () const
std::size_t	nOfCountersToBePrinted ()
void	clearCounters ()

Private Attributes
std::map< std::string, std::reference_wrapper< Gaudi::Accumulators::PrintableCounter >, std::less<> >	m_counters
std::mutex	m_mutex

Detailed Description

template<class BASE>
class CounterHolder< BASE >

Definition at line 25 of file CounterHolder.h.

Member Function Documentation

clearCounters()

template<class BASE>

void CounterHolder< BASE >::clearCounters ( )

inline

Definition at line 61 of file CounterHolder.h.

                       {
    auto lock = std::scoped_lock{m_mutex};
    m_counters.clear();
  }

declareCounter()

template<class BASE>

void CounterHolder< BASE >::declareCounter ( std::string  tag, Gaudi::Accumulators::PrintableCounter &  r  )

inline

Definition at line 32 of file CounterHolder.h.

                                                                             {
    auto lock = std::scoped_lock{m_mutex};
    m_counters.emplace( std::move( tag ), r );
  }

findCounter()

template<class BASE>

const Gaudi::Accumulators::PrintableCounter* CounterHolder< BASE >::findCounter ( std::string_view  tag ) const

inline

Definition at line 37 of file CounterHolder.h.

                                                                                   {
    auto lock = std::scoped_lock{m_mutex};
    auto p    = m_counters.find( tag );
    return p != m_counters.end() ? &p->second.get() : nullptr;
  }

forEachCounter()

template<class BASE>

template<typename Callable >

void CounterHolder< BASE >::forEachCounter ( Callable &&  f ) const

inline

Definition at line 44 of file CounterHolder.h.

                                            {
    auto lock = std::scoped_lock{m_mutex};
    std::for_each( m_counters.begin(), m_counters.end(),
                   [f = std::forward<Callable>( f )]( const auto& p ) { std::invoke( f, p.first, p.second.get() ); } );
  }

nCounters()

template<class BASE>

int CounterHolder< BASE >::nCounters ( ) const

inline

Definition at line 50 of file CounterHolder.h.

                        {
    auto lock = std::scoped_lock{m_mutex};
    return m_counters.size();
  }

nOfCountersToBePrinted()

template<class BASE>

std::size_t CounterHolder< BASE >::nOfCountersToBePrinted ( )

inline

Definition at line 55 of file CounterHolder.h.

                                     {
    auto lock = std::scoped_lock{m_mutex};
    return count_if( begin( m_counters ), end( m_counters ),
                     []( const auto& c ) { return c.second.get().toBePrinted(); } );
  }

Member Data Documentation

m_counters

template<class BASE>

std::map<std::string, std::reference_wrapper<Gaudi::Accumulators::PrintableCounter>, std::less<> > CounterHolder< BASE >::m_counters

private

Definition at line 67 of file CounterHolder.h.

m_mutex

template<class BASE>

std::mutex CounterHolder< BASE >::m_mutex

mutableprivate

Definition at line 68 of file CounterHolder.h.

---

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

• GaudiKernel/GaudiKernel/CounterHolder.h