ObjectList.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_OBJECTLIST_H
#define GAUDIKERNEL_OBJECTLIST_H


// Include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/StreamBuffer.h"
#include "GaudiKernel/ObjectContainerBase.h"

#include <list>
#include <iomanip>


// Definition of the CLID for this class  defined in ClassID.h
// static const CLID CLID_ObjectList = (1<<18);  // ObjectList   (bit 18 set)

template <class TYPE>
class ObjectList : public ObjectContainerBase {

public:
  typedef TYPE                                                 contained_type;
  typedef typename std::list<TYPE*>::value_type                value_type;

  typedef typename std::list<TYPE*>::reference                 reference;
  typedef typename std::list<TYPE*>::const_reference           const_reference;

  typedef typename std::list<TYPE*>::iterator                  iterator;
  typedef typename std::list<TYPE*>::const_iterator            const_iterator;

  typedef typename std::list<TYPE*>::reverse_iterator          reverse_iterator;
  typedef typename std::list<TYPE*>::const_reverse_iterator    const_reverse_iterator;

#ifdef _WIN32
  typedef typename std::vector<TYPE*>::_Tptr                   pointer;
  typedef typename std::vector<TYPE*>::_Ctptr                  const_pointer;
#else
  typedef typename std::vector<TYPE*>::pointer                 pointer;
  typedef typename std::vector<TYPE*>::const_pointer           const_pointer;
#endif

public:
  ObjectList()
    : m_list(0) { }
  ObjectList( const ObjectList<TYPE>& value )
    : m_list(value.m_list) { }

  virtual ~ObjectList() {
    clear();
  }

  virtual const CLID& clID() const {
    return ObjectList<TYPE>::classID();
  }
  static const CLID& classID() {
    static CLID clid = TYPE::classID() + CLID_ObjectList;
    return clid;
  }

  typename ObjectList<TYPE>::iterator begin () {
    return m_list.begin();
  }

  typename ObjectList<TYPE>::const_iterator begin () const {
    return m_list.begin();
  }

  typename ObjectList<TYPE>::iterator end () {
    return m_list.end();
  }

  typename ObjectList<TYPE>::const_iterator end () const {
    return m_list.end();
  }

  typename ObjectList<TYPE>::reverse_iterator rbegin () {
    return m_list.rbegin();
  }

  typename ObjectList<TYPE>::const_reverse_iterator rbegin () const {
    return m_list.rbegin();
  }

  typename ObjectList<TYPE>::reverse_iterator rend () {
    return m_list.rend();
  }

  typename ObjectList<TYPE>::const_reverse_iterator rend () const {
    return m_list.rend();
  }

  typename ObjectList<TYPE>::size_type size () const {
    return m_list.size();
  }
  virtual typename ObjectList<TYPE>::size_type numberOfObjects() const {
    return m_list.size();
  }

  typename ObjectList<TYPE>::size_type max_size () const {
    return m_list.max_size();
  }

  bool empty () const {
    return m_list.empty();
  }

  typename ObjectList<TYPE>::reference front () {
    return m_list.front();
  }

  typename ObjectList<TYPE>::const_reference front () const {
    return m_list.front();
  }

  typename ObjectList<TYPE>::reference back () {
    return m_list.back();
  }

  typename ObjectList<TYPE>::const_reference back () const {
    return m_list.back();
  }

  void push_back( typename ObjectList<TYPE>::const_reference value ) {
    if( 0 != value->parent() ) {
      const_cast<ObjectContainerBase*>(value->parent())->remove(value);
    }
    value->setParent(this);
    m_list.push_back(value);
  }

  virtual long add(ContainedObject* pObject) {
    try {
      typename ObjectList<TYPE>::value_type ptr =
            dynamic_cast<typename ObjectList<TYPE>::value_type>(pObject);
      if ( 0 != ptr ) {
        push_back(ptr);
        return m_list.size()-1;
      }
    }
    catch(...) {
    }
    return -1;
  }

  void pop_back () {
    typename ObjectList<TYPE>::value_type position = m_list.back();
    // Set the back pointer to 0 to avoid repetitional searching
    // for the object in the container, and deleting the object
    position->setParent (0);
    delete position;
    // Removing from the container itself
    m_list.pop_back();
  }

  virtual long remove(ContainedObject* value) {
    // Find the object of value value
    long idx = 0;
    typename ObjectList<TYPE>::iterator   iter;
    for( iter = begin(); iter != end(); iter++, idx++ )  {
      if( value == *iter ) {
        break;
      }
    }
    if( end() == iter )  {
      // Object cannot be released from the container,
      // as it is not contained in it
      return -1;
    }
    else  {
      // Set the back pointer to 0 to avoid repetitional searching
      // for the object in the container and deleting the object
      (*iter)->setParent (0);
      erase(iter);
      return idx;
    }
  }

  typename ObjectList<TYPE>::iterator insert( typename ObjectList<TYPE>::iterator position,
                                     typename ObjectList<TYPE>::const_reference value ) {
    value->setParent(this);
    typename ObjectList<TYPE>::iterator i = m_list.insert(position, value);
    return i;
  }

  void erase( typename ObjectList<TYPE>::iterator position ) {
    if( 0 != (*position)->parent() ) {
      // Set the back pointer to 0 to avoid repetitional searching
      // for the object in the container, and deleting the object
      (*position)->setParent (0);
      delete *position;
    }
    // Removing from the container itself
    m_list.erase(position);
  }

  void erase( typename ObjectList<TYPE>::iterator first,
              typename ObjectList<TYPE>::iterator last ) {
    for( typename ObjectList<TYPE>::iterator iter = first; iter != last; iter++ )  {
      // Set the back pointer to 0 to avoid repetitional searching
      // for the object in the container, and deleting the object
      (*iter)->setParent (0);
      delete *iter;
    }
    // Removing from the container itself
    m_list.erase(first, last);
  }

  void clear()    {
    erase(begin(), end());
  }

  virtual long index( const ContainedObject* obj ) const {
    long i = 0;
    typename ObjectList<TYPE>::const_iterator   iter;
    for( iter = begin(); iter != end(); iter++ )  {
      if( *iter == obj ) {
        return i;
      }
      i++;
    }
    return -1;
  }

  virtual ContainedObject* containedObject( long dist ) const {
    long i = 0;
    typename ObjectList<TYPE>::const_iterator   iter;
    for( iter = begin(); iter != end(); iter++ )  {
      if( dist == i ) {
        return *iter;
      }
      i++;
    }
    return 0;
  }

  virtual std::ostream& fillStream( std::ostream& s ) const                    {
    s << "class ObjectList :    size = "
      << std::setw(12)
      << size() << "\n";
    // Output the base class
    //ObjectContainerBase::fillStream(s);
    if ( 0 != size() ) {
      s << "\nContents of the STL list :";
      long   count = 0;
      typename ObjectList<TYPE>::const_iterator iter;
      for( iter = m_list.begin(); iter != m_list.end(); iter++, count++ ) {
        s << "\nIndex "
          << std::setw(12)
          << count
          << " of object of type "<< **iter;
      }
    }
    return s;
  }

private:

  std::list<TYPE*> m_list;
};


#endif    // GAUDI_OBJECTLIST_H