TransientFastContainer.h

Go to the documentation of this file.

// $Id: TransientFastContainer.h,v 1.6 2008/10/27 16:41:33 marcocle Exp $
#ifndef GAUDIKERNEL_TRANSIENTFASTCONTAINER_H
#define GAUDIKERNEL_TRANSIENTFASTCONTAINER_H 1

// Include files
#include "GaudiKernel/DataObject.h"
#include <vector>
#include <stdexcept>
#include <typeinfo>
#include <functional>


class TransientFastContainerBase: public DataObject {
public:
  virtual ~TransientFastContainerBase();
  virtual void clear() = 0;
  virtual void free() = 0;
  virtual const std::type_info &containedType() const = 0;
};


template <class T>
struct DefaultObjectCleaner: public std::unary_function<T*,T*>{
  inline T* operator() (T* obj ) const {
    obj->T::~T(); // call the destructor without deallocating memory
    return new(obj) T(); // call the constructor on the memory
  }
  inline T* operator() (T* obj, const T &rhs ) const {
    obj->T::~T(); // call the destructor without deallocating memory
    return new(obj) T(rhs); // call the copy constructor on the memory
  }
  inline T* destruct(T* obj) const {
    obj->T::~T(); // call the destructor without deallocating memory
    return obj; // just return the pointer to the non-initialized chunk
  }
  //inline T* operator() (T* obj ) { /* obj->clean(); */ return obj; }
};


template <class T, class CLEANER = DefaultObjectCleaner<T> >
class TransientFastContainer: public TransientFastContainerBase {
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 typename storage_type::size_type               size_type;

  typedef typename storage_type::iterator                iterator;
  typedef typename storage_type::const_iterator          const_iterator;

  typedef CLEANER                            cleaner_type;

  TransientFastContainer(size_type n=0);

  virtual ~TransientFastContainer( );

  // ---- TransientFastContainerBase implementation ----

  virtual void clear();

  virtual void free();

  virtual const std::type_info &containedType() const { return typeid(contained_type); }

  // ---- inlined functions ----

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

  inline pointer Add(const T &rhs) { return ( m_counter++ < m_current_size ) ? m_cleaner(*(m_end++),rhs) : i_new(rhs); }

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

  inline iterator begin() { return m_storage.begin(); }
  inline const_iterator begin() const { return m_storage.begin(); }

  inline iterator end() { return m_end; }
  inline const_iterator end() const { return m_end; }

  inline size_type size() const { return m_counter; }

  inline pointer operator[] (size_type index)
  { return (index < size()) ? m_storage[index] : throw std::out_of_range("index out of range"), (pointer)NULL; }
  inline const contained_type* operator[] (size_type index) const
  { return (index < size()) ? m_storage[index] : throw std::out_of_range("index out of range"), (const_pointer)NULL; }

  inline pointer at(size_type index) { return operator[] (index); }
  inline const contained_type* at(size_type index) const { return operator[] (index); }

private:

  pointer i_new();

  pointer i_new(const T &rhs);

  size_type      m_counter;

  size_type      m_current_size;

  storage_type m_storage;

  iterator m_end;

  cleaner_type m_cleaner;
};

template <class T, class CLEANER>
TransientFastContainer<T,CLEANER>::TransientFastContainer(size_type n):
  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() 
{
  free();
}


template <class T, class CLEANER>
void TransientFastContainer<T,CLEANER>::clear() {
  m_counter = 0;
  m_end = m_storage.begin();
}

template <class T, class CLEANER>
void TransientFastContainer<T,CLEANER>::free() {
  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>
typename TransientFastContainer<T,CLEANER>::pointer TransientFastContainer<T,CLEANER>::i_new() {
  //++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>
typename TransientFastContainer<T,CLEANER>::pointer TransientFastContainer<T,CLEANER>::i_new(const T &rhs) {
  //++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;
}

#endif // GAUDIKERNEL_TRANSIENTFASTCONTAINER_H