KeyedObjectManager Class to manage keyed objects. More...

#include </scratch/z5/marcocle/lhcb-release/419/GAUDI/GAUDI_v26r1/InstallArea/x86_64-slc6-gcc48-opt/include/GaudiKernel/KeyedObjectManager.h>

Collaboration diagram for Containers::KeyedObjectManager< SETUP >:

[legend]

Public Member Functions
	KeyedObjectManager ()
	Standard Constructor.

virtual	~KeyedObjectManager ()
	Standard Destructor.

void	clearDirect ()
	Clear all direct access fields.

long	insertDirect (ObjectContainerBase b, ContainedObject c, void *o, long k)
	Insert element into direct access map.

long	isDirect () const
	Check if the container is dirty.

void *	object (long key) const
	Retrieve object identified by a key from the container.

long	insert (ObjectContainerBase b, ContainedObject c, void o, long k)
	Insert new object into container.

long	insert (ObjectContainerBase b, ContainedObject c, void *o, long k)
	Insert new object into container.

void *	erase (long key, const void *obj)
	Remove object from container (very inefficient if key is invalid)

long	erase (seq_type::iterator beg, seq_type::iterator end)
	Remove object by sequential iterators.

void	reserve (long size)
	Reserve buffer space.

void	clear ()
	Clear content of the vector.

void	setup (void seq, void *rndm)
	Setup of the Map and the parent object.

	KeyedObjectManager ()
	Standard Constructor.

virtual	~KeyedObjectManager ()
	Standard Destructor.

void	clearDirect ()
	Clear all direct access fields.

long	insertDirect (ObjectContainerBase b, ContainedObject c, void *o, long k)
	Insert element into direct access map.

long	isDirect () const
	Check if the container is dirty.

void *	object (long key) const
	Retrieve object identified by a key from the container.

long	insert (ObjectContainerBase b, ContainedObject c, void o, long k)
	Insert new object into container.

long	insert (ObjectContainerBase b, ContainedObject c, void *o, long k)
	Insert new object into container.

void *	erase (long key, const void *obj)
	Remove object from container (very inefficient if key is invalid)

long	erase (seq_type::iterator beg, seq_type::iterator end)
	Remove object by sequential iterators.

void	reserve (long size)
	Reserve buffer space.

void	clear ()
	Clear content of the vector.

void	setup (void seq, void *rndm)
	Setup of the Map and the parent object.

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.

static CLID	classID ()
	Access CLID for this type of container.

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

typedef std::vector< void * >	seq_type

Private Member Functions
void	onDirty () const
	Callback when the container becomes dirty.

void	onDirty () const
	Callback when the container becomes dirty.

template<>
void	onDirty () const

template<>
void	onDirty () const

Private Attributes
seq_type *	m_seq
	Container holding array like container.

long	m_direct
	Dirty flag.

long	m_keyCtxt

union {
char buffer [128]
	Buffer space to hold keyed container.

SETUP * s

}	m_setup

union {
char buffer [128]
	Buffer space to hold keyed container.

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 48 of file KeyedObjectManager.h.

template<class SETUP >

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

private

Definition at line 48 of file KeyedObjectManager.h.

Constructor & Destructor Documentation

template<class T >

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

Standard Constructor.

Definition at line 91 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",
                         0);
  }
  m_setup.s = ::new(m_setup.buffer+sizeof(m_setup.s)) T();
  m_keyCtxt = -1;
}

template<class T >

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

virtual

Standard Destructor.

Definition at line 104 of file KeyedObjectManager.cpp.

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

template<class SETUP >

Containers::KeyedObjectManager< SETUP >::KeyedObjectManager ( )

Standard Constructor.

template<class SETUP >

virtual Containers::KeyedObjectManager< SETUP >::~KeyedObjectManager ( )

virtual

Standard Destructor.

Member Function Documentation

template<class SETUP >

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

static

Access CLID for this type of container.

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 323 of file KeyedObjectManager.cpp.

                                                      {
    return CLID_ObjectVector+0x00030000;
  }

template<>

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

Definition at line 327 of file KeyedObjectManager.cpp.

                                                          {
    return CLID_ObjectVector+0x00040000;
  }

template<>

CLID Containers::KeyedObjectManager< __A >::classID ( )

Definition at line 563 of file KeyedObjectManager.cpp.

                                          {
  return CLID_ObjectVector+0x00050000;
}

template<>

CLID Containers::KeyedObjectManager< __V >::classID ( )

Definition at line 666 of file KeyedObjectManager.cpp.

                                          {
  return CLID_ObjectVector+0x00060000;
}

template<class T >

void Containers::KeyedObjectManager< T >::clear ( )

Clear content of the vector.

Definition at line 265 of file KeyedObjectManager.cpp.

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

template<class SETUP >

void Containers::KeyedObjectManager< SETUP >::clear ( )

Clear content of the vector.

template<class T >

void Containers::KeyedObjectManager< T >::clearDirect ( )

Clear all direct access fields.

Definition at line 272 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<class SETUP >

void Containers::KeyedObjectManager< SETUP >::clearDirect ( )

Clear all direct access fields.

template<>

void Containers::KeyedObjectManager< __A >::clearDirect ( )

Definition at line 462 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 637 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 213 of file KeyedObjectManager.cpp.

                                                                {
  typedef typename T::map_type MTYP;
  typedef find<MTYP> FND;
  if ( 1 == m_direct )   {
    typename T::map_type& m = m_setup.s->m;
    typename T::map_type::iterator i = (0==obj) ? m_setup.s->m.find(key)
      : std::find_if(m.begin(),m.end(),FND(obj));
    if ( i != m_setup.s->m.end() )   {
      void* o = (*i).second;
      seq_type::iterator 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 SETUP >

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

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

template<class T >

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

Remove object by sequential iterators.

Definition at line 290 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 ( seq_type::iterator j=beg; j != end; ++j)  {
      typename T::map_type& m = m_setup.s->m;
      typename T::map_type::iterator i = std::find_if(m.begin(),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<class SETUP >

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

Remove object by sequential iterators.

template<>

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

Definition at line 471 of file KeyedObjectManager.cpp.

{
  typedef std::vector<long> id_type;
  typedef id_type::iterator id_iter;
  if ( 0 == m_direct )    {
    onDirty();
    return erase(key, obj);
  }
  if ( 0 != obj )   {
    id_type& idx = m_setup.s->m_idx;
    for ( id_iter i=idx.begin(); i != idx.end(); i++ )    {
      seq_type::iterator j = m_setup.s->v.begin()+(*i);
      seq_type::iterator 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(*i));
        *i = -1;
        return o;
      }
    }
  }
  else if ( key >= 0 && key < long(m_setup.s->m_idx.size()) )   {
    id_iter idx = m_setup.s->m_idx.begin()+key;
    if ( *idx != -1 )   {
      seq_type::iterator i = m_setup.s->v.begin()+(*idx);
      if ( i == m_setup.s->v.end() )   {
        containerIsInconsistent();
      }
      void* o = *i;
      seq_type::iterator 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 0;
}

template<>

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

Definition at line 524 of file KeyedObjectManager.cpp.

{
  typedef std::vector<long> id_type;
  typedef id_type::iterator id_iter;
  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 ( id_iter i=idx.begin(); i != idx.end(); i++ )    {
      seq_type::iterator j = m_setup.s->v.begin()+(*i);
      seq_type::iterator 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(*i));
        *i = -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 645 of file KeyedObjectManager.cpp.

{
  invalidContainerOperation();
  return 0;
}

template<>

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

Definition at line 654 of file KeyedObjectManager.cpp.

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

template<class SETUP >

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

Insert new object into container.

template<class T >

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

Insert new object into container.

Definition at line 127 of file KeyedObjectManager.cpp.

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

template<class SETUP >

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

Insert new object into container.

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 138 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 396 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);
  }
  std::vector<long>::iterator 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 593 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 607 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 SETUP >

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

Insert element into direct access map.

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 176 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 428 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);
  }
  std::vector<long>::iterator 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 621 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 73 of file KeyedObjectManager.h.

{ return m_direct; }

template<class SETUP >

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

inline

Check if the container is dirty.

Definition at line 73 of file KeyedObjectManager.h.

{ return m_direct; }

template<class SETUP >

void* Containers::KeyedObjectManager< SETUP >::object ( long key ) const

Retrieve object identified by a key from the container.

template<class T >

void * Containers::KeyedObjectManager< T >::object ( long key ) const

Retrieve object identified by a key from the container.

Definition at line 237 of file KeyedObjectManager.cpp.

{
  if ( 0 == m_direct )   {
    onDirty();
  }
  typename T::map_type::const_iterator i = m_setup.s->m.find(key);
  if ( i != m_setup.s->m.end() )  {
    return (*i).second;
  }
  return 0;
}

template<>

void * Containers::KeyedObjectManager< __A >::object ( long value ) const

Definition at line 347 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 0;
#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 580 of file KeyedObjectManager.cpp.

{
  invalidContainerOperation();
  return 0;
}

template<class SETUP >

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

private

Callback when the container becomes dirty.

template<class T >

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

private

Callback when the container becomes dirty.

Definition at line 118 of file KeyedObjectManager.cpp.

                                                       {
  m_direct = 1;
  for(int i = 0, stop = m_setup.s->v.size(); i < stop; i++ )   {
    m_setup.s->insert(*(m_setup.s->v.begin()+i), i);
  }
  m_setup.s->v.clear();
}

template<>

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

private

Definition at line 364 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] == 0 )  {
      containerIsInconsistent();
    }
    m_setup.s->m_idx.push_back(i);
  }
}

template<>

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

private

Definition at line 587 of file KeyedObjectManager.cpp.

                                               {
  invalidContainerOperation();
}

template<class SETUP >

void Containers::KeyedObjectManager< SETUP >::reserve ( long size )

Reserve buffer space.

template<class T >

void Containers::KeyedObjectManager< T >::reserve ( long size )

Reserve buffer space.

Definition at line 250 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 111 of file KeyedObjectManager.cpp.

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

template<class SETUP >

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

Setup of the Map and the parent object.

Member Data Documentation

template<class SETUP >

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

Buffer space to hold keyed container.

Definition at line 56 of file KeyedObjectManager.h.

template<class SETUP >

long Containers::KeyedObjectManager< SETUP >::m_direct

mutableprivate

Dirty flag.

Definition at line 52 of file KeyedObjectManager.h.

template<class SETUP >

long Containers::KeyedObjectManager< SETUP >::m_keyCtxt

mutableprivate

Definition at line 53 of file KeyedObjectManager.h.

template<class SETUP >

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

private

Container holding array like container.

Definition at line 50 of file KeyedObjectManager.h.

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

template<class SETUP >

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

Definition at line 57 of file KeyedObjectManager.h.

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

InstallArea/x86_64-slc6-gcc48-opt/include/GaudiKernel/KeyedObjectManager.h
InstallArea/x86_64-slc6-gcc48-opt/include/GaudiKernel/KeyedObjectManager.h
GaudiKernel/src/Lib/KeyedObjectManager.cpp

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

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

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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