Implementation of the AIDA IAnnotation interface class. More...

#include <GaudiCommonSvc/Annotation.h>

Inheritance diagram for AIDA::Annotation:

Collaboration diagram for AIDA::Annotation:

[legend]

Classes
struct	AnnotationItem
	Internal private annotation item class. More...

Public Member Functions
bool	addItem (const std::string &key, const std::string &value, bool sticky=false) override
	Add a key/value pair with a given sticky. More...

bool	removeItem (const std::string &key) override
	Remove the item indicated by a given key. More...

std::string	value (const std::string &key) const override
	Retrieve the value for a given key. More...

void	setValue (const std::string &key, const std::string &value) override
	Set value for a given key. More...

void	setSticky (const std::string &key, bool sticky) override
	Set sticky for a given key. More...

int	size () const override
	Get the number of items in the Annotation. More...

std::string	key (int index) const override
	Individual access to the Annotation-items. More...

std::string	value (int index) const override

void	reset () override
	Remove all the non-sticky items. More...

Private Attributes
std::vector< AnnotationItem >	m_annotationItems
	The vector of the annotation items. More...

std::map< std::string, unsigned int >	m_identifiers
	The map of strings to identifiers. More...

std::string	emptyString

Detailed Description

Implementation of the AIDA IAnnotation interface class.

Definition at line 16 of file Annotation.h.

Member Function Documentation

bool AIDA::Annotation::addItem	(	const std::string &	key,
		const std::string &	value,
		bool	sticky = `false`
	)

inlineoverride

Add a key/value pair with a given sticky.

Definition at line 67 of file Annotation.h.

                                                                                                {
   if ( m_identifiers.find( key ) != m_identifiers.end() ) return false;
   m_annotationItems.emplace_back( key, value, sticky );
   m_identifiers.emplace( key, m_annotationItems.size() - 1 );
   return true;
 }

std::string AIDA::Annotation::key ( int index ) const

inlineoverride

Individual access to the Annotation-items.

Definition at line 119 of file Annotation.h.

                                                       {
   if ( index < 0 || index >= static_cast<int>( m_annotationItems.size() ) ) return emptyString;
   return m_annotationItems[index].m_key;
 }

bool AIDA::Annotation::removeItem ( const std::string & key )

inlineoverride

Remove the item indicated by a given key.

Definition at line 74 of file Annotation.h.

                                                              {
   auto iKey = m_identifiers.find( key );
   if ( iKey == m_identifiers.end() ) return false;
 
   unsigned int indexToBeRemoved = iKey->second;
   // check stickness
 
   if ( m_annotationItems[indexToBeRemoved].m_sticky ) return false;
 
   // why rebuilding ?
 
   m_identifiers.clear();
   std::vector<AnnotationItem> annotationItemsNew;
   if ( m_annotationItems.size() > 1 ) annotationItemsNew.reserve( m_annotationItems.size() - 1 );
   for ( unsigned int iItem = 0; iItem < m_annotationItems.size(); ++iItem ) {
     if ( iItem == indexToBeRemoved ) continue;
     const auto& item = m_annotationItems[iItem];
     annotationItemsNew.emplace_back( item.m_key, item.m_value, item.m_sticky );
     m_identifiers.emplace( item.m_key, annotationItemsNew.size() - 1 );
   }
   m_annotationItems = std::move( annotationItemsNew );
   return true;
 }

void AIDA::Annotation::reset ( )

inlineoverride

Remove all the non-sticky items.

Definition at line 129 of file Annotation.h.

                                   {
   // Collect the non-sticky items
   std::vector<std::string> itemsToRemove;
   itemsToRemove.reserve( size() );
   for ( const auto& item : m_annotationItems ) {
     if ( !item.m_sticky ) itemsToRemove.push_back( item.m_key );
   }
   for ( const auto& i : itemsToRemove ) removeItem( i );
 }

void AIDA::Annotation::setSticky	(	const std::string &	key,
		bool	sticky
	)

inlineoverride

Set sticky for a given key.

Definition at line 112 of file Annotation.h.

                                                                          {
   auto iKey = m_identifiers.find( key );
   if ( iKey != m_identifiers.end() ) m_annotationItems[iKey->second].m_sticky = sticky;
 }

void AIDA::Annotation::setValue	(	const std::string &	key,
		const std::string &	value
	)

inlineoverride

Set value for a given key.

Definition at line 103 of file Annotation.h.

                                                                                    {
   auto iKey = m_identifiers.find( key );
   if ( iKey == m_identifiers.end() )
     // if not found, then add it
     addItem( key, value );
   else
     m_annotationItems[iKey->second].m_value = value;
 }

int AIDA::Annotation::size ( ) const

inlineoverride

Get the number of items in the Annotation.

Definition at line 117 of file Annotation.h.

117 { return m_annotationItems.size(); }

AIDA::Annotation::m_annotationItems

std::vector< AnnotationItem > m_annotationItems

The vector of the annotation items.

Definition: Annotation.h:58

std::string AIDA::Annotation::value ( const std::string & key ) const

inlineoverride

Retrieve the value for a given key.

Definition at line 98 of file Annotation.h.

                                                                    {
   auto iKey = m_identifiers.find( key );
   return iKey != m_identifiers.end() ? m_annotationItems[iKey->second].m_value : emptyString;
 }

std::string AIDA::Annotation::value ( int index ) const

inlineoverride

Definition at line 124 of file Annotation.h.

                                                         {
   if ( index < 0 || index >= static_cast<int>( m_annotationItems.size() ) ) return emptyString;
   return m_annotationItems[index].m_value;
 }

Member Data Documentation

std::string AIDA::Annotation::emptyString

private

Definition at line 63 of file Annotation.h.

std::vector<AnnotationItem> AIDA::Annotation::m_annotationItems

private

The vector of the annotation items.

Definition at line 58 of file Annotation.h.

std::map<std::string, unsigned int> AIDA::Annotation::m_identifiers

private

The map of strings to identifiers.

Definition at line 61 of file Annotation.h.

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

GaudiCommonSvc/GaudiCommonSvc/Annotation.h

Classes

Public Member Functions

Private Attributes

Detailed Description

Member Function Documentation

Member Data Documentation