AthenaAttributeListSpecification Class Reference

#include <CoralBase/AthenaAttributeListSpecification.h>

Collaboration diagram for AthenaAttributeListSpecification:

Classes
class	const_iterator
	The iterator class. More...

Public Member Functions
	AthenaAttributeListSpecification ()
	Constructor. More...
	AthenaAttributeListSpecification (const AthenaAttributeListSpecification &rhs)
	Copy constructor. More...
	AthenaAttributeListSpecification (const coral::AttributeListSpecification &rhs)
	Copy constructor. More...
void	release () const
	Decrements the reference counter. More...
template<typename T >
void	extend (const std::string &name, const std::string &unitName="UNKNOWN", const std::string &groupName="UNKNOWN")
	Appends a new specification. More...
void	extend (const std::string &name, const std::string &typeName, const std::string &unitName="UNKNOWN", const std::string &groupName="UNKNOWN")
void	extend (const std::string &name, const std::type_info &type, const std::string &unitName="UNKNOWN", const std::string &groupName="UNKNOWN")
void	extend (const std::string &name, const AthenaAttributeType &type)
void	extend (const AthenaAttributeSpecification &row)
size_t	size () const
	Returns the size of the specification. More...
bool	operator== (const AthenaAttributeListSpecification &rhs) const
	Equal operator. Compares only types and values. Not the attribute names. More...
bool	operator!= (const AthenaAttributeListSpecification &rhs) const
	Comparison operator. Compares only types and values. Not the attribute names. More...
int	index (const std::string &name) const
	Returns the index of a specification given its name. If the name is not found it returns -1. More...
const AthenaAttributeSpecification &	operator[] (size_t index) const
	Bracket operator. More...
const AthenaAttributeSpecification &	specificationForAttribute (int index) const
	Returns the specification given an index. More...
void	coralSpec (coral::AttributeListSpecification &) const
	Fills a coral Specification. More...
const_iterator	begin () const
	Returns a forward iterator. More...
const_iterator	end () const

Protected Member Functions
void	addRef () const
	~AthenaAttributeListSpecification ()
	The destructor is private. More...
AthenaAttributeListSpecification &	operator= (const AthenaAttributeListSpecification &)
	No assignment operator. More...

Private Attributes
std::atomic< int >	m_counter
	The reference counter. More...
std::vector< AthenaAttributeSpecification * >	m_attributeSpecifications
	The specifications. More...
std::map< std::string, int >	m_mapOfNameToIndex
	The map of names to indices. More...

Friends
class	AthenaAttributeList
	Increments the reference counter only the AttributeList can call this method. More...

Detailed Description

The specification of an AttributeList

Definition at line 42 of file AthenaAttributeListSpecification.h.

Constructor & Destructor Documentation

AthenaAttributeListSpecification() [1/3]

AthenaAttributeListSpecification::AthenaAttributeListSpecification ( )

inline

Constructor.

Definition at line 236 of file AthenaAttributeListSpecification.h.

                                                                  :
  m_counter( 1 ),
  m_attributeSpecifications(),
  m_mapOfNameToIndex()
{}

AthenaAttributeListSpecification() [2/3]

AthenaAttributeListSpecification::AthenaAttributeListSpecification ( const AthenaAttributeListSpecification &  rhs )

inline

Copy constructor.

Definition at line 243 of file AthenaAttributeListSpecification.h.

                                                                                                               :
  m_counter( 1 ),
  m_attributeSpecifications(),
  m_mapOfNameToIndex( rhs.m_mapOfNameToIndex )
{
  for ( std::vector< AthenaAttributeSpecification* >::const_iterator iSpecification = rhs.m_attributeSpecifications.begin();
        iSpecification != rhs.m_attributeSpecifications.end(); ++iSpecification ) {
    m_attributeSpecifications.push_back( new AthenaAttributeSpecification( **iSpecification ) );
  }
}

AthenaAttributeListSpecification() [3/3]

AthenaAttributeListSpecification::AthenaAttributeListSpecification ( const coral::AttributeListSpecification &  rhs )

inline

Copy constructor.

Definition at line 255 of file AthenaAttributeListSpecification.h.

                                                                                                              :
  m_counter( 1 ),
  m_attributeSpecifications(),
  m_mapOfNameToIndex()
{
  //std::cerr << "AthenaAttributeListSpecification (coral version) with counter = " << m_counter << std::endl;
  for ( coral::AttributeListSpecification::const_iterator iSpecification = rhs.begin();
        iSpecification != rhs.end(); ++iSpecification ) 
  {
    this->extend(iSpecification->name(),iSpecification->typeName());
  }
}

~AthenaAttributeListSpecification()

AthenaAttributeListSpecification::~AthenaAttributeListSpecification ( )

inlineprotected

The destructor is private.

Definition at line 269 of file AthenaAttributeListSpecification.h.

{
  //std::cerr << "In AthenaAttributeListSpecification destructor" << std::endl;
  for ( std::vector< AthenaAttributeSpecification* >::iterator iSpecification = m_attributeSpecifications.begin();
        iSpecification != m_attributeSpecifications.end(); ++iSpecification ) delete *iSpecification;
}

Member Function Documentation

addRef()

void AthenaAttributeListSpecification::addRef ( ) const

inlineprotected

Definition at line 278 of file AthenaAttributeListSpecification.h.

{
  ++m_counter;
}

begin()

AthenaAttributeListSpecification::const_iterator AthenaAttributeListSpecification::begin ( ) const

inline

Returns a forward iterator.

Definition at line 163 of file AthenaAttributeListSpecification.h.

{
  return AthenaAttributeListSpecification::const_iterator( m_attributeSpecifications.begin() );
}

coralSpec()

void AthenaAttributeListSpecification::coralSpec ( coral::AttributeListSpecification &  s ) const

inline

Fills a coral Specification.

Definition at line 362 of file AthenaAttributeListSpecification.h.

{
  for (AthenaAttributeListSpecification::const_iterator i = this->begin();
       i != this->end();
       ++i)
  {
    s.extend( i->name(), i->attributeType().typeName() );
  }
}

end()

AthenaAttributeListSpecification::const_iterator AthenaAttributeListSpecification::end ( ) const

inline

Definition at line 170 of file AthenaAttributeListSpecification.h.

{
  return AthenaAttributeListSpecification::const_iterator( m_attributeSpecifications.end() );
}

extend() [1/5]

void AthenaAttributeListSpecification::extend ( const AthenaAttributeSpecification &  row )

inline

Definition at line 332 of file AthenaAttributeListSpecification.h.

{
  if ( m_mapOfNameToIndex.find( aas.name() ) != m_mapOfNameToIndex.end() )
    throw coral::AttributeListException( "An attribute with the name \"" + aas.name() + "\" exists already" );
  m_attributeSpecifications.push_back( new AthenaAttributeSpecification( aas ) );
  m_mapOfNameToIndex.insert( std::make_pair( aas.name(), static_cast<int>( m_attributeSpecifications.size() - 1 ) ) );
}

extend() [2/5]

void AthenaAttributeListSpecification::extend ( const std::string &  name, const AthenaAttributeType &  type  )

inline

Definition at line 321 of file AthenaAttributeListSpecification.h.

{
  if ( m_mapOfNameToIndex.find( name ) != m_mapOfNameToIndex.end() )
    throw coral::AttributeListException( "An attribute with the name \"" + name + "\" exists already" );
  m_attributeSpecifications.push_back( new AthenaAttributeSpecification( name, typeName ) );
  m_mapOfNameToIndex.insert( std::make_pair( name, static_cast<int>( m_attributeSpecifications.size() - 1 ) ) );
}

extend() [3/5]

void AthenaAttributeListSpecification::extend ( const std::string &  name, const std::string &  typeName, const std::string &  unitName = "UNKNOWN", const std::string &  groupName = "UNKNOWN"  )

inline

Definition at line 294 of file AthenaAttributeListSpecification.h.

{
  if ( m_mapOfNameToIndex.find( name ) != m_mapOfNameToIndex.end() )
    throw coral::AttributeListException( "An attribute with the name \"" + name + "\" exists already" );
  m_attributeSpecifications.push_back( new AthenaAttributeSpecification( name, typeName, unitName, groupName ) );
  m_mapOfNameToIndex.insert( std::make_pair( name, static_cast<int>( m_attributeSpecifications.size() - 1 ) ) );
}

extend() [4/5]

template<typename T >

void AthenaAttributeListSpecification::extend	(	const std::string &	name,
		const std::string &	unitName = "UNKNOWN",
		const std::string &	groupName = "UNKNOWN"
	)

Appends a new specification.

Definition at line 149 of file AthenaAttributeListSpecification.h.

{
  this->extend( name, typeid(T), unitName, groupName );
}

extend() [5/5]

void AthenaAttributeListSpecification::extend ( const std::string &  name, const std::type_info &  type, const std::string &  unitName = "UNKNOWN", const std::string &  groupName = "UNKNOWN"  )

inline

Definition at line 307 of file AthenaAttributeListSpecification.h.

{ 
  std::string typeName = System::typeinfoName(typeInfo);
  if ( m_mapOfNameToIndex.find( name ) != m_mapOfNameToIndex.end() )
    throw coral::AttributeListException( "An attribute with the name \"" + name + "\" exists already" );
  m_attributeSpecifications.push_back( new AthenaAttributeSpecification( name, typeName, unitName, groupName ) );
  m_mapOfNameToIndex.insert( std::make_pair( name, static_cast<int>( m_attributeSpecifications.size() - 1 ) ) );
}

index()

int AthenaAttributeListSpecification::index ( const std::string &  name ) const

inline

Returns the index of a specification given its name. If the name is not found it returns -1.

Definition at line 342 of file AthenaAttributeListSpecification.h.

{
  std::map<std::string, int>::const_iterator iSpecificationForAttribute = m_mapOfNameToIndex.find( name );
  if ( iSpecificationForAttribute == m_mapOfNameToIndex.end() ) return -1;
  else return iSpecificationForAttribute->second;
}

operator!=()

bool AthenaAttributeListSpecification::operator!= ( const AthenaAttributeListSpecification &  rhs ) const

inline

Comparison operator. Compares only types and values. Not the attribute names.

Definition at line 230 of file AthenaAttributeListSpecification.h.

{
  return ( ! ( *this == rhs ) );
}

operator=()

AthenaAttributeListSpecification& AthenaAttributeListSpecification::operator= ( const AthenaAttributeListSpecification &  )

protected

No assignment operator.

operator==()

bool AthenaAttributeListSpecification::operator== ( const AthenaAttributeListSpecification &  rhs ) const

inline

Equal operator. Compares only types and values. Not the attribute names.

Definition at line 374 of file AthenaAttributeListSpecification.h.

{
  if ( this->size() != rhs.size() ) return false;
  size_t theSize = this->size();
  const AthenaAttributeListSpecification& lhs = *this;
  for ( size_t i = 0; i < theSize; ++i )
    //if ( (*this)[i] != rhs[i] )
    if ( lhs[i] != rhs[i] )
      return false;
  return true;
}

operator[]()

const AthenaAttributeSpecification & AthenaAttributeListSpecification::operator[] ( size_t  index ) const

inline

Bracket operator.

Definition at line 224 of file AthenaAttributeListSpecification.h.

{
  return this->specificationForAttribute( static_cast<int>( index ) );
}

release()

void AthenaAttributeListSpecification::release ( ) const

inline

Decrements the reference counter.

Definition at line 285 of file AthenaAttributeListSpecification.h.

{
  //std::cerr << "Before decrement " << std::endl;
  //std::cerr << "AthenaAttributeListSpecification release called "
  //          << "with counter = " << m_counter << std::endl;
  if (--m_counter == 0) delete this;
}

size()

size_t AthenaAttributeListSpecification::size ( ) const

inline

Returns the size of the specification.

Definition at line 156 of file AthenaAttributeListSpecification.h.

{
  return m_attributeSpecifications.size();
}

specificationForAttribute()

const AthenaAttributeSpecification & AthenaAttributeListSpecification::specificationForAttribute ( int  index ) const

inline

Returns the specification given an index.

Definition at line 351 of file AthenaAttributeListSpecification.h.

{
  if ( index < 0 || index >= static_cast<int>( m_attributeSpecifications.size() ) )
    throw coral::AttributeListException( "Invalid index for the attribute already" );
  return *( m_attributeSpecifications[ index ] );
}

Friends And Related Function Documentation

AthenaAttributeList

friend class AthenaAttributeList

friend

Increments the reference counter only the AttributeList can call this method.

Definition at line 124 of file AthenaAttributeListSpecification.h.

Member Data Documentation

m_attributeSpecifications

std::vector< AthenaAttributeSpecification* > AthenaAttributeListSpecification::m_attributeSpecifications

private

The specifications.

Definition at line 138 of file AthenaAttributeListSpecification.h.

m_counter

std::atomic<int> AthenaAttributeListSpecification::m_counter

mutableprivate

The reference counter.

Definition at line 135 of file AthenaAttributeListSpecification.h.

m_mapOfNameToIndex

std::map< std::string, int > AthenaAttributeListSpecification::m_mapOfNameToIndex

private

The map of names to indices.

Definition at line 141 of file AthenaAttributeListSpecification.h.

---

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

• AthenaAttributeListSpecification.h