| # Gaudi Framework, version v22r4 |

Home |  | Generated: Fri Sep 2 2011

Public Types | Public Member Functions | Private Member Functions | Private Attributes

# TransientFastContainer< T, CLEANER > Class Template Reference

Container providing internal memory management. More...

`#include <GaudiKernel/TransientFastContainer.h>`

Inheritance diagram for TransientFastContainer< T, CLEANER >:
[legend]
Collaboration diagram for TransientFastContainer< T, CLEANER >:
[legend]

List of all members.

## Public Types
typedef T | contained_type
typedef contained_type * | value_type
typedef value_type | pointer
typedef const value_type | const_pointer
typedef value_type | reference
typedef const value_type | const_reference
typedef std::vector< value_type > | storage_type
typedef storage_type::size_type | size_type
typedef storage_type::iterator | iterator
typedef storage_type::const_iterator | const_iterator
typedef CLEANER | cleaner_type
## Public Member Functions
| TransientFastContainer (size_type n=0)
| Standard constructor. If the argument n is not zero, n objects are instantiated.
virtual | ~TransientFastContainer ()
| Delete all the recorded objects.
virtual void | clear ()
| Set the internal counter to 0 without actually deleting the objects.
virtual void | free ()
| Delete all the contained objects to free memory.
virtual const std::type_info & | containedType () const
| Return type information on the contained objects.
pointer | New ()
| Add a new object to the container or reuse one of the already available objects (after cleaning), and return a pointer to it.
pointer | Add (const T &rhs)
| Add a new object to the container or reuse one of the already available objects (after cleaning), and return a pointer to it.
pointer | NewPointer ()
| Get a pointer to a non-initialized chunk of memory either destructing an already existing object or creating a new one and destructing it.
iterator | begin ()
| Iterator pointing to the first object of the container.
const_iterator | begin () const
| Const iterator pointing to the first object of the container.
iterator | end ()
| Iterator pointing after the last used object in the container.
const_iterator | end () const
| Const iterator pointing after the last used object in the container.
size_type | size () const
| Returns the number of used objects in the container.
pointer | operator[] (size_type index)
| Accessor to the object at the given index. Throws std::out_of_range if index is greater than size().
const contained_type * | operator[] (size_type index) const
| Const accessor to the object at the given index. Throws std::out_of_range if index is greater than size().
pointer | at (size_type index)
| Same as operator[]().
const contained_type * | at (size_type index) const
| Same as operator[]() const.
## Private Member Functions
pointer | i_new ()
| Implementation function that instantiate a new object.
pointer | i_new (const T &rhs)
| Implementation function that instantiate a new object using the copy constructor.
## Private Attributes
size_type | m_counter
| Internal counter.
size_type | m_current_size
| Number of already allocated objects.
storage_type | m_storage
| Repository of allocated objects.
iterator | m_end
| Iterator that is returned by end().
cleaner_type | m_cleaner
| Instance of the class that cleans new objects.

## Detailed Description

### template<class T, class CLEANER = DefaultObjectCleaner<T>>
class TransientFastContainer< T, CLEANER >

Container providing internal memory management.

New objects are added to the container using the member function New(). Those are not deleted until destruction of the container. When the method clear() is called, the internal of the container is set to 0 and it behaves as if it is, but it still has memory of all the created object. When the New() is invoked on a "cleared" container, it returns the pointer of the first non-used of the known objects after calling an instance of CLEANER on it, or a new object if all the know objects are already in use.

Author:
  Marco Clemencic

Date:
  2006-05-02

Definition at line 83 of file TransientFastContainer.h.

## Member Typedef Documentation

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef CLEANER TransientFastContainer< T, CLEANER >::cleaner_type

Definition at line 102 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef storage_type::const_iterator TransientFastContainer< T, CLEANER >::const_iterator

Definition at line 100 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef const value_type TransientFastContainer< T, CLEANER >::const_pointer

Definition at line 90 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef const value_type TransientFastContainer< T, CLEANER >::const_reference

Definition at line 93 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef T TransientFastContainer< T, CLEANER >::contained_type

Definition at line 86 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef storage_type::iterator TransientFastContainer< T, CLEANER >::iterator

Definition at line 99 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef value_type TransientFastContainer< T, CLEANER >::pointer

Definition at line 89 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef value_type TransientFastContainer< T, CLEANER >::reference

Definition at line 92 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef storage_type::size_type TransientFastContainer< T, CLEANER >::size_type

Definition at line 97 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef std::vector<value_type> TransientFastContainer< T, CLEANER >::storage_type

Definition at line 95 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

typedef contained_type* TransientFastContainer< T, CLEANER >::value_type

Definition at line 87 of file TransientFastContainer.h.

## Constructor & Destructor Documentation

template<class T , class CLEANER >

TransientFastContainer< T, CLEANER >::TransientFastContainer | ( | size_type | n = `0` ) |

Standard constructor. If the argument n is not zero, n objects are instantiated.

Definition at line 186 of file TransientFastContainer.h.

                                                                        :
      TransientFastContainerBase(),
      m_counter(0),
      m_current_size(0),
      m_storage(),
      m_end(m_storage.begin()),
      m_cleaner()
    {
      if (n>0) {
        m_storage.reserve(n);
        for(;n>0;--n) New();
        clear();
      }
    }

template<class T , class CLEANER >

TransientFastContainer< T, CLEANER >::~TransientFastContainer | ( | ) | `[virtual]`

Delete all the recorded objects.

Definition at line 202 of file TransientFastContainer.h.

    {
      free();
    }

## Member Function Documentation

template<class T, class CLEANER = DefaultObjectCleaner<T>>

pointer TransientFastContainer< T, CLEANER >::Add | ( | const T & | rhs ) | `[inline]`

Add a new object to the container or reuse one of the already available objects (after cleaning), and return a pointer to it.

Definition at line 129 of file TransientFastContainer.h.

    { return ( m_counter++ < m_current_size ) ? m_cleaner(*(m_end++),rhs) : i_new(rhs); }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

pointer TransientFastContainer< T, CLEANER >::at | ( | size_type | index ) | `[inline]`

Same as operator[]().

Definition at line 157 of file TransientFastContainer.h.

    { return operator[] (index); }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

const contained_type* TransientFastContainer< T, CLEANER >::at | ( | size_type | index ) | const`[inline]`

Same as operator[]() const.

Definition at line 159 of file TransientFastContainer.h.

    { return operator[] (index); }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

const_iterator TransientFastContainer< T, CLEANER >::begin | ( | void | ) | const`[inline]`

Const iterator pointing to the first object of the container.

Definition at line 139 of file TransientFastContainer.h.

    { return m_storage.begin(); }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

iterator TransientFastContainer< T, CLEANER >::begin | ( | void | ) | `[inline]`

Iterator pointing to the first object of the container.

Definition at line 137 of file TransientFastContainer.h.

    { return m_storage.begin(); }

template<class T , class CLEANER >

void TransientFastContainer< T, CLEANER >::clear | ( | void | ) | `[virtual]`

Set the internal counter to 0 without actually deleting the objects.

Implements TransientFastContainerBase.

Definition at line 209 of file TransientFastContainer.h.

                                                  {
      m_counter = 0;
      m_end = m_storage.begin();
    }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

virtual const std::type_info& TransientFastContainer< T, CLEANER >::containedType | ( | ) | const`[inline, virtual]`

Return type information on the contained objects.

Implements TransientFastContainerBase.

Definition at line 119 of file TransientFastContainer.h.

    { return typeid(contained_type); }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

iterator TransientFastContainer< T, CLEANER >::end | ( | void | ) | `[inline]`

Iterator pointing after the last used object in the container.

Definition at line 142 of file TransientFastContainer.h.

    { return m_end; }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

const_iterator TransientFastContainer< T, CLEANER >::end | ( | void | ) | const`[inline]`

Const iterator pointing after the last used object in the container.

Definition at line 144 of file TransientFastContainer.h.

    { return m_end; }

template<class T , class CLEANER >

void TransientFastContainer< T, CLEANER >::free | ( | ) | `[virtual]`

Delete all the contained objects to free memory.

Implements TransientFastContainerBase.

Definition at line 215 of file TransientFastContainer.h.

                                                 {
      for( typename storage_type::iterator i = m_storage.begin();
           i != m_storage.end();
           ++i ) {
        delete *i;
      }
      m_storage.clear();
      m_counter = m_current_size = 0;
      m_end = m_storage.begin();
    }

template<class T , class CLEANER >

TransientFastContainer< T, CLEANER >::pointer TransientFastContainer< T, CLEANER >::i_new | ( | const T & | rhs ) | `[private]`

Implementation function that instantiate a new object using the copy constructor.

Definition at line 237 of file TransientFastContainer.h.

                                                                                                           {
      //++m_counter; // already incremented in New()
      ++m_current_size;
      pointer ptr = new T(rhs);
      m_storage.push_back(ptr);
      m_end = m_storage.end();
      return ptr;
    }

template<class T , class CLEANER >

TransientFastContainer< T, CLEANER >::pointer TransientFastContainer< T, CLEANER >::i_new | ( | ) | `[private]`

Implementation function that instantiate a new object.

Definition at line 227 of file TransientFastContainer.h.

                                                                                               {
      //++m_counter; // already incremented in New()
      ++m_current_size;
      pointer ptr = new T();
      m_storage.push_back(ptr);
      m_end = m_storage.end();
      return ptr;
    }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

pointer TransientFastContainer< T, CLEANER >::New | ( | ) | `[inline]`

Add a new object to the container or reuse one of the already available objects (after cleaning), and return a pointer to it.

Definition at line 125 of file TransientFastContainer.h.

    { return ( m_counter++ < m_current_size ) ? m_cleaner(*(m_end++)) : i_new(); }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

pointer TransientFastContainer< T, CLEANER >::NewPointer | ( | ) | `[inline]`

Get a pointer to a non-initialized chunk of memory either destructing an already existing object or creating a new one and destructing it.

Definition at line 133 of file TransientFastContainer.h.

      { return ( m_counter++ < m_current_size ) ?  m_cleaner.destruct(*(m_end++)) : m_cleaner.destruct(i_new()); }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

const contained_type* TransientFastContainer< T, CLEANER >::operator[] | ( | size_type | index ) | const`[inline]`

Const accessor to the object at the given index. Throws std::out_of_range if index is greater than size().

Definition at line 153 of file TransientFastContainer.h.

      { return (index < size()) ? m_storage[index] : throw std::out_of_range("index out of range"), (const_pointer)NULL; }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

pointer TransientFastContainer< T, CLEANER >::operator[] | ( | size_type | index ) | `[inline]`

Accessor to the object at the given index. Throws std::out_of_range if index is greater than size().

Definition at line 150 of file TransientFastContainer.h.

      { return (index < size()) ? m_storage[index] : throw std::out_of_range("index out of range"), (pointer)NULL; }

template<class T, class CLEANER = DefaultObjectCleaner<T>>

size_type TransientFastContainer< T, CLEANER >::size | ( | void | ) | const`[inline]`

Returns the number of used objects in the container.

Definition at line 147 of file TransientFastContainer.h.

    { return m_counter; }

## Member Data Documentation

template<class T, class CLEANER = DefaultObjectCleaner<T>>

cleaner_type TransientFastContainer< T, CLEANER >::m_cleaner`[private]`

Instance of the class that cleans new objects.

Definition at line 182 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

size_type TransientFastContainer< T, CLEANER >::m_counter`[private]`

Internal counter.

Definition at line 170 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

size_type TransientFastContainer< T, CLEANER >::m_current_size`[private]`

Number of already allocated objects.

Definition at line 173 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

iterator TransientFastContainer< T, CLEANER >::m_end`[private]`

Iterator that is returned by end().

Definition at line 179 of file TransientFastContainer.h.

template<class T, class CLEANER = DefaultObjectCleaner<T>>

storage_type TransientFastContainer< T, CLEANER >::m_storage`[private]`

Repository of allocated objects.

Definition at line 176 of file TransientFastContainer.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r4/GaudiKernel/GaudiKernel/TransientFastContainer.h

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines