Containers::KeyedObjectManager< SETUP > Class Template Reference

KeyedObjectManager Class to manage keyed objects. More...

#include <GaudiKernel/KeyedObjectManager.h>

Collaboration diagram for Containers::KeyedObjectManager< SETUP >:

Public Member Functions
	KeyedObjectManager ()
	Standard Constructor. More...
	KeyedObjectManager (KeyedObjectManager &&other)
virtual	~KeyedObjectManager ()
	Standard Destructor. More...
void	clearDirect ()
	Clear all direct access fields. More...
long	insertDirect (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
	Insert element into direct access map. More...
long	isDirect () const
	Check if the container is dirty. More...
void *	object (long key) const
	Retrieve object identified by a key from the container. More...
long	insert (ObjectContainerBase *b, ContainedObject *c, void *o, long *k)
	Insert new object into container. More...
long	insert (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
	Insert new object into container. More...
void *	erase (long key, const void *obj)
	Remove object from container (very inefficient if key is invalid) More...
long	erase (seq_type::iterator beg, seq_type::iterator end)
	Remove object by sequential iterators. More...
void	reserve (long size)
	Reserve buffer space. More...
void	clear ()
	Clear content of the vector. More...
void	setup (void *seq, void **rndm)
	Setup of the Map and the parent object. More...
template<>
CLID	classID ()
template<>
CLID	classID ()
template<>
void *	object (long value) const
template<>
long	insert (ObjectContainerBase *b, ContainedObject *c, void *o, long *k)
template<>
long	insert (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
template<>
long	insertDirect (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
template<>
void	clearDirect ()
template<>
void *	erase (long key, const void *obj)
template<>
long	erase (seq_type::iterator beg, seq_type::iterator end)
template<>
CLID	classID ()
template<>
void *	object (long) const
template<>
long	insert (ObjectContainerBase *b, ContainedObject *c, void *o, long *k)
template<>
long	insert (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
template<>
long	insertDirect (ObjectContainerBase *b, ContainedObject *c, void *o, long k)
template<>
void	clearDirect ()
template<>
void *	erase (long, const void *)
template<>
long	erase (seq_type::iterator beg, seq_type::iterator end)
template<>
CLID	classID ()

Static Public Member Functions
static CLID	classID ()
	Access CLID for this type of container. More...

Private Types
typedef std::vector< void * >	seq_type

Private Member Functions
void	onDirty () const
	Callback when the container becomes dirty. More...
template<>
void	onDirty () const
template<>
void	onDirty () const

Private Attributes
seq_type *	m_seq
	Container holding array like container. More...
long	m_direct
	Dirty flag. More...
long	m_keyCtxt
union {
char   buffer [128]
	Buffer space to hold keyed container. More...
SETUP *   s
}	m_setup

Detailed Description

template<class SETUP>
class Containers::KeyedObjectManager< SETUP >

KeyedObjectManager Class to manage keyed objects.

Object manager class.

This class is instantiated for two container types: map and hashmap. Other types are possible, but currently not supported. Other implementations may be achieved by specializing the SETUP class.

As an example below the specialization for a vector like implementation is shown.

Author

M.Frank CERN/LHCb

Version

1.0

Definition at line 46 of file KeyedObjectManager.h.

Member Typedef Documentation

template<class SETUP>

typedef std::vector<void*> Containers::KeyedObjectManager< SETUP >::seq_type

private

Definition at line 49 of file KeyedObjectManager.h.

Constructor & Destructor Documentation

template<class T >

Containers::KeyedObjectManager< T >::KeyedObjectManager

(

)

Standard Constructor.

Definition at line 97 of file KeyedObjectManager.cpp.

                                                    : m_seq( nullptr ), m_direct( 0 )
{
  if ( sizeof( typename T::map_type ) > sizeof( m_setup.buffer ) ) {
    throw GaudiException( "Basic STL contaier sizes are incompatible", "KeyedContainer", StatusCode::FAILURE );
  }
  m_setup.s = ::new ( m_setup.buffer + sizeof( m_setup.s ) ) T();
  m_keyCtxt = -1;
}

template<class T >

Containers::KeyedObjectManager< T >::KeyedObjectManager

(

KeyedObjectManager< SETUP > &&

other

)

Definition at line 107 of file KeyedObjectManager.cpp.

    : m_seq( nullptr ), m_direct( other.m_direct ), m_keyCtxt( other.m_keyCtxt )
{
  m_setup.s = ::new ( m_setup.buffer + sizeof( m_setup.s ) ) T( std::move( *other.m_setup.s ) );

  other.m_keyCtxt = -1;
  other.m_seq     = nullptr;
  other.m_direct  = 0;
}

template<class T >

Containers::KeyedObjectManager< T >::~KeyedObjectManager ( )

virtual

Standard Destructor.

Definition at line 118 of file KeyedObjectManager.cpp.

{
  m_setup.s->~T();
}

Member Function Documentation

template<class SETUP>

static CLID Containers::KeyedObjectManager< SETUP >::classID ( )

static

Access CLID for this type of container.

template<>

CLID Containers::KeyedObjectManager< Containers::map >::classID

(

)

Definition at line 319 of file KeyedObjectManager.cpp.

  {
    return CLID_ObjectVector + 0x00030000;
  }

template<>

CLID Containers::KeyedObjectManager< Containers::hashmap >::classID

(

)

Definition at line 324 of file KeyedObjectManager.cpp.

  {
    return CLID_ObjectVector + 0x00040000;
  }

template<>

CLID Containers::KeyedObjectManager< __A >::classID

(

)

Definition at line 542 of file KeyedObjectManager.cpp.

  {
    return CLID_ObjectVector + 0x00050000;
  }

template<>

CLID Containers::KeyedObjectManager< __V >::classID

(

)

Definition at line 638 of file KeyedObjectManager.cpp.

  {
    return CLID_ObjectVector + 0x00060000;
  }

template<class T >

void Containers::KeyedObjectManager< T >::clear

(

)

Clear content of the vector.

Definition at line 262 of file KeyedObjectManager.cpp.

{
  clearDirect();
  m_seq->clear();
}

template<class T >

void Containers::KeyedObjectManager< T >::clearDirect

(

)

Clear all direct access fields.

Definition at line 269 of file KeyedObjectManager.cpp.

{
  switch ( m_direct ) {
  case 1:
    m_setup.s->m.clear();
    break;
  case 0:
    m_setup.s->v.clear();
    break;
  default:
    break;
  }
  m_direct  = 0;
  m_keyCtxt = -1;
}

template<>

void Containers::KeyedObjectManager< __A >::clearDirect

(

)

Definition at line 453 of file KeyedObjectManager.cpp.

  {
    m_setup.s->v.clear();
    m_setup.s->m_idx.clear();
    m_direct  = 0;
    m_keyCtxt = -1;
  }

template<>

void Containers::KeyedObjectManager< __V >::clearDirect

(

)

Definition at line 610 of file KeyedObjectManager.cpp.

  {
    m_setup.s->v.clear();
    m_direct  = 0;
    m_keyCtxt = -1;
  }

template<class T >

void * Containers::KeyedObjectManager< T >::erase	(	long	key,
		const void *	obj
	)

Remove object from container (very inefficient if key is invalid)

Definition at line 215 of file KeyedObjectManager.cpp.

{
  typedef typename T::map_type MTYP;
  typedef find<MTYP>           FND;
  if ( 1 == m_direct ) {
    auto& m = m_setup.s->m;
    auto  i = ( obj ? std::find_if( m.begin(), m.end(), FND( obj ) ) : m_setup.s->m.find( key ) );
    if ( i != m_setup.s->m.end() ) {
      void* o = i->second;
      auto  j = std::find( m_seq->begin(), m_seq->end(), o );
      if ( j != m_seq->end() ) {
        m_seq->erase( j );
        m_setup.s->m.erase( i );
        return o;
      }
    }
    containerIsInconsistent();
  }
  onDirty();
  return erase( key, obj );
}

template<class T >

long Containers::KeyedObjectManager< T >::erase	(	seq_type::iterator	beg,
		seq_type::iterator	end
	)

Remove object by sequential iterators.

Definition at line 287 of file KeyedObjectManager.cpp.

{
  typedef typename T::map_type MTYP;
  typedef find<MTYP>           FND;
  if ( 0 == m_direct ) {
    onDirty();
    return erase( beg, end );
  }
  if ( beg == m_seq->begin() && end == m_seq->end() ) {
    clear();
  } else {
    for ( auto j = beg; j != end; ++j ) {
      //      auto& m = m_setup.s->m;
      auto i = std::find_if( m_setup.s->m.begin(), m_setup.s->m.end(), FND( *j ) );
      if ( i != m_setup.s->m.end() ) {
        m_setup.s->m.erase( i );
        continue;
      }
      containerIsInconsistent();
    }
    m_seq->erase( beg, end );
  }
  return OBJ_ERASED;
}

template<>

void * Containers::KeyedObjectManager< __A >::erase	(	long	key,
		const void *	obj
	)

Definition at line 463 of file KeyedObjectManager.cpp.

  {
    typedef std::vector<long> id_type;
    if ( 0 == m_direct ) {
      onDirty();
      return erase( key, obj );
    }
    if ( obj ) {
      id_type& idx = m_setup.s->m_idx;
      for ( auto& elem : idx ) {
        auto j = m_setup.s->v.begin() + ( elem );
        auto k = std::find( m_seq->begin(), m_seq->end(), *j );
        if ( *j == obj ) {
          void* o = *j;
          m_seq->erase( k );
          m_setup.s->v.erase( j );
          std::for_each( m_setup.s->m_idx.begin(), m_setup.s->m_idx.end(), array::decrement( elem ) );
          elem = -1;
          return o;
        }
      }
    } else if ( key >= 0 && key < long( m_setup.s->m_idx.size() ) ) {
      auto idx = m_setup.s->m_idx.begin() + key;
      if ( *idx != -1 ) {
        auto i = m_setup.s->v.begin() + ( *idx );
        if ( i == m_setup.s->v.end() ) {
          containerIsInconsistent();
        }
        void* o = *i;
        auto  j = std::find( m_seq->begin(), m_seq->end(), o );
        if ( j == m_seq->end() ) {
          containerIsInconsistent();
        }
        m_seq->erase( j );
        m_setup.s->v.erase( i );
        std::for_each( m_setup.s->m_idx.begin(), m_setup.s->m_idx.end(), array::decrement( *idx ) );
        *idx = -1;
        return o;
      }
    }
    containerIsInconsistent();
    return nullptr;
  }

template<>

long Containers::KeyedObjectManager< __A >::erase	(	seq_type::iterator	beg,
		seq_type::iterator	end
	)

Definition at line 509 of file KeyedObjectManager.cpp.

  {
    typedef std::vector<long> id_type;
    if ( beg == m_seq->begin() && end == m_seq->end() ) {
      clear();
      return OBJ_ERASED;
    } else if ( 0 == m_direct ) {
      onDirty();
      return erase( beg, end );
    } else {
      long     cnt = 0, nobj = end - beg;
      id_type& idx = m_setup.s->m_idx;
      for ( auto& elem : idx ) {
        auto j = m_setup.s->v.begin() + ( elem );
        auto k = std::find( beg, end, *j );
        if ( k != end ) {
          m_setup.s->v.erase( j );
          std::for_each( m_setup.s->m_idx.begin(), m_setup.s->m_idx.end(), array::decrement( elem ) );
          elem = -1;
          cnt++;
          if ( cnt == nobj ) break;
        }
      }
      m_seq->erase( beg, end );
      if ( cnt != nobj ) {
        containerIsInconsistent();
      }
      return OBJ_ERASED;
    }
    // cannot reach this point
  }

template<>

void * Containers::KeyedObjectManager< __V >::erase	(	long	,
		const void *
	)

Definition at line 619 of file KeyedObjectManager.cpp.

  {
    invalidContainerOperation();
    return nullptr;
  }

template<>

long Containers::KeyedObjectManager< __V >::erase	(	seq_type::iterator	beg,
		seq_type::iterator	end
	)

Definition at line 627 of file KeyedObjectManager.cpp.

  {
    if ( beg == m_seq->begin() && end == m_seq->end() ) {
      clear();
      return OBJ_ERASED;
    }
    invalidContainerOperation();
    return OBJ_ERASED;
  }

template<class T >

long Containers::KeyedObjectManager< T >::insert	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long *	k
	)

Insert new object into container.

Definition at line 142 of file KeyedObjectManager.cpp.

{
  *key = ++m_keyCtxt;
  return insert( pBase, pObject, obj, *key );
}

template<class T >

long Containers::KeyedObjectManager< T >::insert	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long	k
	)

Insert new object into container.

Keep major key value

Definition at line 150 of file KeyedObjectManager.cpp.

{
  if ( key > m_keyCtxt ) {
    m_keyCtxt = key;
  }
  if ( 1 == m_direct ) {
    if ( m_setup.s->insert( obj, key ) ) {
      if ( !pObject->parent() ) {
        pObject->setParent( pBase );
      }
      m_seq->push_back( obj );
      return OBJ_INSERTED;
    }
  } else if ( key == long( m_setup.s->v.size() ) ) {
    m_setup.s->v.push_back( obj );
    if ( !pObject->parent() ) {
      pObject->setParent( pBase );
    }
    m_seq->push_back( obj );
    return OBJ_INSERTED;
  } else {
    // Document is dirty now...
    // need to copy all pointers from the vector to the map
    onDirty();
    return insert( pBase, pObject, obj, key );
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

template<>

long Containers::KeyedObjectManager< __A >::insert	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long *	k
	)

Definition at line 377 of file KeyedObjectManager.cpp.

  {
    // auto key creation only possible for direct access!
    if ( 0 == m_direct ) {
      m_seq->push_back( o );
      m_setup.s->v.push_back( o );
      if ( !c->parent() ) c->setParent( b );
      *k = ++m_keyCtxt;
      return OBJ_INSERTED;
    }
    cannotInsertToContainer();
    return OBJ_CANNOT_INSERT;
  }

template<>

long Containers::KeyedObjectManager< __A >::insert	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long	k
	)

Keep major key value

Extend redirection array and insert

Definition at line 393 of file KeyedObjectManager.cpp.

  {
    if ( 0 == m_direct ) {
      if ( k == m_keyCtxt + 1 ) {
        return insert( b, c, o, &k );
      }
      onDirty();
      return insert( b, c, o, k );
    }
    if ( k > m_keyCtxt ) m_keyCtxt = k;
    if ( k + 1 > long( m_setup.s->m_idx.size() ) ) {
      m_setup.s->m_idx.resize( k + 1, -1 );
    }
    auto idx = m_setup.s->m_idx.begin() + k;
    if ( *idx == -1 ) {
      *idx = m_setup.s->v.size();
      m_setup.s->v.push_back( o );
      m_seq->push_back( o );
      if ( !c->parent() ) c->setParent( b );
      return OBJ_INSERTED;
    }
    cannotInsertToContainer();
    return OBJ_CANNOT_INSERT;
  }

template<>

long Containers::KeyedObjectManager< __V >::insert	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long *	k
	)

Definition at line 575 of file KeyedObjectManager.cpp.

  {
    m_seq->push_back( o );
    m_setup.s->v.push_back( o );
    if ( !c->parent() ) c->setParent( b );
    *k = ( m_setup.s->v.size() - 1 );
    return OBJ_INSERTED;
  }

template<>

long Containers::KeyedObjectManager< __V >::insert	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long	k
	)

Definition at line 586 of file KeyedObjectManager.cpp.

  {
    if ( k == long( m_setup.s->v.size() ) ) {
      return insert( b, c, o, &k );
    }
    cannotInsertToContainer();
    return OBJ_CANNOT_INSERT;
  }

template<class T >

long Containers::KeyedObjectManager< T >::insertDirect	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long	k
	)

Insert element into direct access map.

Keep major key value

Definition at line 183 of file KeyedObjectManager.cpp.

{
  if ( key > m_keyCtxt ) {
    m_keyCtxt = key;
  }
  if ( 1 == m_direct ) {
    if ( m_setup.s->insert( obj, key ) ) {
      if ( !pObject->parent() ) {
        pObject->setParent( pBase );
      }
      return OBJ_INSERTED;
    }
  } else if ( key == long( m_setup.s->v.size() ) ) {
    m_setup.s->v.push_back( obj );
    if ( !pObject->parent() ) {
      pObject->setParent( pBase );
    }
    return OBJ_INSERTED;
  } else {
    // Document is dirty now...
    // need to copy all pointers from the vector to the map
    onDirty();
    return insertDirect( pBase, pObject, obj, key );
  }
  cannotInsertToContainer();
  return OBJ_CANNOT_INSERT;
}

template<>

long Containers::KeyedObjectManager< __A >::insertDirect	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long	k
	)

Keep major key value

Extend redirection array and insert

Definition at line 422 of file KeyedObjectManager.cpp.

  {
    if ( 0 == m_direct ) {
      if ( k == m_keyCtxt + 1 ) {
        m_setup.s->v.push_back( o );
        if ( !c->parent() ) c->setParent( b );
        ++m_keyCtxt;
        return OBJ_INSERTED;
      }
      onDirty();
      return insertDirect( b, c, o, k );
    }
    if ( k > m_keyCtxt ) m_keyCtxt = k;
    if ( k + 1 > long( m_setup.s->m_idx.size() ) ) {
      m_setup.s->m_idx.resize( k + 1, -1 );
    }
    auto idx = m_setup.s->m_idx.begin() + k;
    if ( *idx == -1 ) {
      *idx = m_setup.s->v.size();
      m_setup.s->v.push_back( o );
      if ( !c->parent() ) c->setParent( b );
      return OBJ_INSERTED;
    }
    cannotInsertToContainer();
    return OBJ_CANNOT_INSERT;
  }

template<>

long Containers::KeyedObjectManager< __V >::insertDirect	(	ObjectContainerBase *	b,
		ContainedObject *	c,
		void *	o,
		long	k
	)

Definition at line 597 of file KeyedObjectManager.cpp.

  {
    if ( k == long( m_setup.s->v.size() ) ) {
      m_setup.s->v.push_back( o );
      if ( !c->parent() ) c->setParent( b );
      return OBJ_INSERTED;
    }
    cannotInsertToContainer();
    return OBJ_CANNOT_INSERT;
  }

template<class SETUP>

long Containers::KeyedObjectManager< SETUP >::isDirect ( ) const

inline

Check if the container is dirty.

Definition at line 75 of file KeyedObjectManager.h.

{ return m_direct; }

template<class T >

void * Containers::KeyedObjectManager< T >::object

(

long

key

)

const

Retrieve object identified by a key from the container.

Definition at line 238 of file KeyedObjectManager.cpp.

{
  if ( 0 == m_direct ) onDirty();
  auto i = m_setup.s->m.find( key );
  if ( i != m_setup.s->m.end() ) return ( *i ).second;
  return nullptr;
}

template<>

void * Containers::KeyedObjectManager< __A >::object

(

long

value

)

const

Definition at line 346 of file KeyedObjectManager.cpp.

  {
#ifdef CHECK_KEYED_CONTAINER
    unsigned long siz = m_setup.s->m_idx.size();
    if ( value >= 0 && size_t( value ) < siz ) {
      long ent = *( m_setup.s->m_idx.begin() + value );
      if ( ent >= 0 ) {
        return *( m_setup.s->v.begin() + ent );
      }
    }
    return nullptr;
#else
    return *( m_setup.s->v.begin() + ( *( m_setup.s->m_idx.begin() + value ) ) );
#endif
  }

template<>

void * Containers::KeyedObjectManager< __V >::object

(

long

)

const

Definition at line 561 of file KeyedObjectManager.cpp.

  {
    invalidContainerOperation();
    return nullptr;
  }

template<class T >

void Containers::KeyedObjectManager< T >::onDirty ( ) const

private

Callback when the container becomes dirty.

Definition at line 132 of file KeyedObjectManager.cpp.

{
  m_direct = 1;
  auto& s  = *m_setup.s;
  long  i  = 0;
  for ( auto p : s.v ) s.insert( p, i++ );
  s.v.clear();
}

template<>

void Containers::KeyedObjectManager< __A >::onDirty ( ) const

private

Definition at line 363 of file KeyedObjectManager.cpp.

  {
    m_direct = 1;
    m_setup.s->m_idx.reserve( m_setup.s->v.size() + 1 );
    for ( int i = 0, stop = m_setup.s->v.size(); i < stop; ++i ) {
      if ( !m_setup.s->v[i] ) {
        containerIsInconsistent();
      }
      m_setup.s->m_idx.push_back( i );
    }
  }

template<>

void Containers::KeyedObjectManager< __V >::onDirty ( ) const

private

Definition at line 568 of file KeyedObjectManager.cpp.

  {
    invalidContainerOperation();
  }

template<class T >

void Containers::KeyedObjectManager< T >::reserve

(

long

size

)

Reserve buffer space.

Definition at line 247 of file KeyedObjectManager.cpp.

{
  switch ( m_direct ) {
  case 1:
    break;
  case 0:
    m_setup.s->v.reserve( len );
    break;
  default:
    break;
  }
  m_seq->reserve( len );
}

template<class T >

void Containers::KeyedObjectManager< T >::setup	(	void *	seq,
		void **	rndm
	)

Setup of the Map and the parent object.

Definition at line 125 of file KeyedObjectManager.cpp.

{
  m_seq = (seq_type*)seq;
  *rndm = &m_setup.s->v;
}

Member Data Documentation

template<class SETUP>

char Containers::KeyedObjectManager< SETUP >::buffer[128]

Buffer space to hold keyed container.

Definition at line 57 of file KeyedObjectManager.h.

template<class SETUP>

long Containers::KeyedObjectManager< SETUP >::m_direct

mutableprivate

Dirty flag.

Definition at line 53 of file KeyedObjectManager.h.

template<class SETUP>

long Containers::KeyedObjectManager< SETUP >::m_keyCtxt

mutableprivate

Definition at line 54 of file KeyedObjectManager.h.

template<class SETUP>

seq_type* Containers::KeyedObjectManager< SETUP >::m_seq

private

Container holding array like container.

Definition at line 51 of file KeyedObjectManager.h.

union { ... } Containers::KeyedObjectManager< SETUP >::m_setup

template<class SETUP>

SETUP* Containers::KeyedObjectManager< SETUP >::s

Definition at line 58 of file KeyedObjectManager.h.

---

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

• GaudiKernel/GaudiKernel/KeyedObjectManager.h
• GaudiKernel/src/Lib/KeyedObjectManager.cpp