#include <TrigHolderStructure.h>

Inheritance diagram for HLT::TrigHolderStructure:

Collaboration diagram for HLT::TrigHolderStructure:

Public Member Functions
	TrigHolderStructure ()
void	reset ()
bool	registerHolder (const std::shared_ptr< BaseHolder > &holder)
template<typename HolderType = BaseHolder>
HolderType *	getHolder (class_id_type clid, const std::variant< sub_index_type, std::string > &stiOrLabel) const
template<typename HolderType = BaseHolder>
HolderType *	getHolderForFeature (const TriggerElement::FeatureAccessHelper &fea) const
template<typename HolderType = BaseHolder>
std::vector< HolderType * >	getAllHolders () const
template<typename HolderType = BaseHolder>
std::vector< HolderType * >	getHoldersOfClid (class_id_type clid) const
sub_index_type	getSubTypeIndex (class_id_type clid, const index_or_label_type &stiOrLabel) const
std::string	getLabel (class_id_type clid, const index_or_label_type &stiOrLabel) const
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Types
typedef std::map< sub_index_type, std::shared_ptr< BaseHolder > >	IndexToHolderMap
typedef std::map< std::string, sub_index_type >	LabelToSubIndexMap
typedef std::map< sub_index_type, std::string >	SubIndexToLabelMap

Private Member Functions
BaseHolder *	getBaseHolder (class_id_type clid, sub_index_type sti) const
template<typename T>
T *	getCastHolder (BaseHolder *holder) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::map< class_id_type, IndexToHolderMap >	m_holderByClidAndIndex
std::map< class_id_type, SubIndexToLabelMap >	m_lookupLabels
std::map< class_id_type, LabelToSubIndexMap >	m_lookupSubIndex
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 21 of file TrigHolderStructure.h.

Member Typedef Documentation

◆ IndexToHolderMap

typedef std::map<sub_index_type, std::shared_ptr<BaseHolder> > HLT::TrigHolderStructure::IndexToHolderMap

private

Definition at line 112 of file TrigHolderStructure.h.

◆ LabelToSubIndexMap

typedef std::map<std::string,sub_index_type> HLT::TrigHolderStructure::LabelToSubIndexMap

private

Definition at line 113 of file TrigHolderStructure.h.

◆ SubIndexToLabelMap

typedef std::map<sub_index_type,std::string> HLT::TrigHolderStructure::SubIndexToLabelMap

private

Definition at line 114 of file TrigHolderStructure.h.

Constructor & Destructor Documentation

◆ TrigHolderStructure()

HLT::TrigHolderStructure::TrigHolderStructure ( )

Definition at line 7 of file TrigHolderStructure.cxx.

7 : asg::AsgMessaging("TrigHolderStructure"){

8}

Member Function Documentation

◆ getAllHolders()

template<typename HolderType = BaseHolder>

std::vector< HolderType * > HLT::TrigHolderStructure::getAllHolders ( ) const

inline

Definition at line 40 of file TrigHolderStructure.h.

                                                 {
      std::vector<HolderType*> result;
      for(auto& clid_indexmap : m_holderByClidAndIndex){
    for(auto& index_holder : clid_indexmap.second){
      result.push_back(getCastHolder<HolderType>(index_holder.second.get()));
    }
      }
      return result;
    }

◆ getBaseHolder()

HLT::BaseHolder * HLT::TrigHolderStructure::getBaseHolder	(	class_id_type	clid,
		sub_index_type	sti ) const

private

Definition at line 16 of file TrigHolderStructure.cxx.

                                                                                                 {
  if( sti == HLT::invalid_sub_index){
    ATH_MSG_DEBUG("requested holder with invalid sub_type_index");
    return 0;
  }
  auto allsti_it = m_holderByClidAndIndex.find(clid);
  if(allsti_it == m_holderByClidAndIndex.end()){
    return 0;
  }
  auto sti_holder_map =  allsti_it->second;
  auto holder_it = sti_holder_map.find(sti);
  if(holder_it == sti_holder_map.end()){
    return 0;
  }
  return holder_it->second.get();
}

◆ getCastHolder()

template<typename T>

T * HLT::TrigHolderStructure::getCastHolder ( BaseHolder * holder ) const

inlineprivate

Definition at line 101 of file TrigHolderStructure.h.

                                               {
      if(!holder){
    return 0;
      }
      auto cast_holder = dynamic_cast<T*>(holder);
      if(!cast_holder){
    ATH_MSG_ERROR("cast failed");
      }
      return cast_holder;
    }

◆ getHolder()

template<typename HolderType = BaseHolder>

HolderType * HLT::TrigHolderStructure::getHolder	(	class_id_type	clid,
		const std::variant< sub_index_type, std::string > &	stiOrLabel ) const

inline

Definition at line 30 of file TrigHolderStructure.h.

                                                                                                            {
      return getCastHolder<HolderType>(getBaseHolder(clid,getSubTypeIndex(clid,stiOrLabel)));
    }

◆ getHolderForFeature()

template<typename HolderType = BaseHolder>

HolderType * HLT::TrigHolderStructure::getHolderForFeature ( const TriggerElement::FeatureAccessHelper & fea ) const

inline

Definition at line 35 of file TrigHolderStructure.h.

                                                                                        {
      return getCastHolder<HolderType>(getBaseHolder(fea.getCLID(),fea.getIndex().subTypeIndex()));
    }

◆ getHoldersOfClid()

template<typename HolderType = BaseHolder>

std::vector< HolderType * > HLT::TrigHolderStructure::getHoldersOfClid ( class_id_type clid ) const

inline

Definition at line 51 of file TrigHolderStructure.h.

                                                                      {
      std::vector<HolderType*> result;
      auto lookup_it = m_holderByClidAndIndex.find(clid);
      if(lookup_it == m_holderByClidAndIndex.end()) return result;
 
      for(auto& index_holder : lookup_it->second){
    result.push_back(getCastHolder<HolderType>(index_holder.second.get()));
      }
      return result;
    }

◆ getLabel()

std::string HLT::TrigHolderStructure::getLabel	(	class_id_type	clid,
		const index_or_label_type &	stiOrLabel ) const

inline

Definition at line 78 of file TrigHolderStructure.h.

                                                                                        {
      //short circuit for sub_index_type because that case is valid whether we have a map or not. (visitor only works with map)
      if (stiOrLabel.index() == 1){
    return std::get<std::string>(stiOrLabel);
      }
 
      std::string invalid_label = "inavalid_label";
 
      auto lookup_it = m_lookupLabels.find(clid);
      if(lookup_it == m_lookupLabels.end()) return invalid_label;
 
      auto it = lookup_it->second.find(std::get<sub_index_type>(stiOrLabel));
      if(it==lookup_it->second.end()) return invalid_label;
 
      return  it->second;
    }

◆ getSubTypeIndex()

sub_index_type HLT::TrigHolderStructure::getSubTypeIndex	(	class_id_type	clid,
		const index_or_label_type &	stiOrLabel ) const

inline

Definition at line 63 of file TrigHolderStructure.h.

                                                                                                    {
      //short circuit for sub_index_type because that case is valid whether we have a map or not. (visitor only works with map)
      if (stiOrLabel.index() == 0){
    return std::get<sub_index_type>(stiOrLabel);
      }
 
      auto lookup_it = m_lookupSubIndex.find(clid);
      if(lookup_it == m_lookupSubIndex.end()) return invalid_sub_index;
 
      auto it = lookup_it->second.find(std::get<std::string>(stiOrLabel));
      if(it==lookup_it->second.end()) return invalid_sub_index;
 
      return  it->second;
    }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns: A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns: A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns: boolean Indicting if messages at given level will be printed; true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

◆ registerHolder()

bool HLT::TrigHolderStructure::registerHolder ( const std::shared_ptr< BaseHolder > & holder )

Definition at line 34 of file TrigHolderStructure.cxx.

                                                                                  { 
  auto clid = holder->typeClid();
  auto subtypeindex = holder->subTypeIndex();
  const auto & label = holder->label();
 
  if(getHolder(clid,subtypeindex)){
    ATH_MSG_WARNING("we already have a holder like this! clid:" << clid << " subtypeIndex: " << subtypeindex << " label: " << label);
    return false;
  }
  
  m_holderByClidAndIndex[clid][subtypeindex] = holder;
  m_lookupLabels[clid][subtypeindex] = label;
  m_lookupSubIndex[clid][label] = subtypeindex;
 
  return true;
}

◆ reset()

void HLT::TrigHolderStructure::reset ( )

Definition at line 10 of file TrigHolderStructure.cxx.

                                  {
  m_holderByClidAndIndex.clear();
  m_lookupLabels.clear();
  m_lookupSubIndex.clear();
} 

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_holderByClidAndIndex

std::map<class_id_type, IndexToHolderMap> HLT::TrigHolderStructure::m_holderByClidAndIndex

private

Definition at line 116 of file TrigHolderStructure.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lookupLabels

std::map<class_id_type, SubIndexToLabelMap > HLT::TrigHolderStructure::m_lookupLabels

private

Definition at line 118 of file TrigHolderStructure.h.

◆ m_lookupSubIndex

std::map<class_id_type, LabelToSubIndexMap > HLT::TrigHolderStructure::m_lookupSubIndex

private

Definition at line 119 of file TrigHolderStructure.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ IndexToHolderMap

◆ LabelToSubIndexMap

◆ SubIndexToLabelMap

Constructor & Destructor Documentation

◆ TrigHolderStructure()

Member Function Documentation

◆ getAllHolders()

◆ getBaseHolder()

◆ getCastHolder()

◆ getHolder()

◆ getHolderForFeature()

◆ getHoldersOfClid()

◆ getLabel()

◆ getSubTypeIndex()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ registerHolder()

◆ reset()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_holderByClidAndIndex

◆ m_imsg

◆ m_lookupLabels

◆ m_lookupSubIndex

◆ m_lvl

◆ m_msg_tls

◆ m_nm