CounterHolder< BASE > Class Template Reference

#include <GaudiKernel/CounterHolder.h>

Inheritance diagram for CounterHolder< BASE >:

Collaboration diagram for CounterHolder< BASE >:

Public Member Functions
void	declareCounter (const std::string &tag, Gaudi::Accumulators::PrintableCounter &r)
const Gaudi::Accumulators::PrintableCounter *	findCounter (const std::string &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 > >	m_counters
std::mutex	m_mutex

Detailed Description

template<class BASE>
class CounterHolder< BASE >

Definition at line 16 of file CounterHolder.h.

Member Function Documentation

clearCounters()

template<class BASE>

void CounterHolder< BASE >::clearCounters ( )

inline

Definition at line 52 of file CounterHolder.h.

                       {
    std::lock_guard lock{m_mutex};
    m_counters.clear();
  }

declareCounter()

template<class BASE>

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

inline

Definition at line 23 of file CounterHolder.h.

                                                                                    {
    std::lock_guard lock{m_mutex};
    m_counters.emplace( tag, r );
  }

findCounter()

template<class BASE>

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

inline

Definition at line 28 of file CounterHolder.h.

                                                                                     {
    std::lock_guard 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 35 of file CounterHolder.h.

                                            {
    std::lock_guard 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 41 of file CounterHolder.h.

                        {
    std::lock_guard lock{m_mutex};
    return m_counters.size();
  }

nOfCountersToBePrinted()

template<class BASE>

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

inline

Definition at line 46 of file CounterHolder.h.

                                     {
    std::lock_guard 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> > CounterHolder< BASE >::m_counters

private

Definition at line 58 of file CounterHolder.h.

m_mutex

template<class BASE>

std::mutex CounterHolder< BASE >::m_mutex

mutableprivate

Definition at line 59 of file CounterHolder.h.

---

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

• GaudiKernel/GaudiKernel/CounterHolder.h