SmartRefVector.h

Go to the documentation of this file.

//  ====================================================================
//  SmartRefVector.h
//  --------------------------------------------------------------------
//
//  Package   : Kernel
//
//  Author    : Markus Frank
//
//  ====================================================================
#ifndef KERNEL_SMARTREFVECTOR_H
#define KERNEL_SMARTREFVECTOR_H 1

// STL include files
#include <vector>

// Include files
#include "GaudiKernel/SmartRef.h"

template <class TYPE>
class SmartRefVector : public std::vector<SmartRef<TYPE>> {
protected:
  typedef SmartRef<TYPE> _Entry;
  typedef std::vector<_Entry>                          _Base;
  typedef typename std::vector<_Entry>::const_iterator _BaseConstIter;
  typedef typename std::vector<_Entry>::value_type     _BaseValueType;

  mutable const DataObject* m_data;
  mutable const ContainedObject* m_contd;

  void _setEnvironment( const DataObject* pObj, const ContainedObject* pContd ) const {
    m_data  = pObj;
    m_contd = pContd;
    for ( _BaseConstIter i = _Base::begin(); i != _Base::end(); i++ ) { ( *i )._setEnvironment( pObj, pContd ); }
  }

public:
  SmartRefVector() {
    m_contd = 0;
    m_data  = 0;
  }
  template <class ITERATOR>
  SmartRefVector( ITERATOR first, ITERATOR last )
      : std::vector<SmartRef<TYPE>>( first, last ), m_data( 0 ), m_contd( 0 ) {}
  SmartRefVector( const SmartRefVector& copy ) : std::vector<SmartRef<TYPE>>( copy ) { *this = copy; }
  // virtual ~SmartRefVector()                  {
  //}

  SmartRefVector<TYPE>& operator()( ContainedObject* pObj ) {
    _setEnvironment( ( 0 == pObj ) ? 0 : pObj->parent(), pObj );
    return *this;
  }
  const SmartRefVector<TYPE>& operator()( const ContainedObject* pObj ) const {
    _setEnvironment( ( 0 == pObj ) ? 0 : pObj->parent(), pObj );
    return *this;
  }
  SmartRefVector<TYPE>& operator()( DataObject* pObj ) {
    _setEnvironment( pObj, 0 );
    return *this;
  }
  const SmartRefVector<TYPE>& operator()( const DataObject* pObj ) const {
    _setEnvironment( pObj, 0 );
    return *this;
  }
  SmartRefVector<TYPE>& operator=( const SmartRefVector<TYPE>& copy ) {
    _Base::operator=( copy );
    // Harms.... MF
    // on copy we MUST make a 1 to 1 copy
    // _setEnvironment( copy.m_data, copy.m_contd );
    // use instead:
    m_data  = copy.m_data;
    m_contd = copy.m_contd;
    return *this;
  }
  const std::type_info* type() const { return &typeid( TYPE ); }
  StreamBuffer& readRefs( StreamBuffer& s );
  StreamBuffer& writeRefs( StreamBuffer& s ) const;
  // MCl: it is "_s" instead of the most common "s" to avoid a fake icc remark #1599
  friend StreamBuffer& operator<<( StreamBuffer& _s, const SmartRefVector<TYPE>& ptr ) { return ptr.writeRefs( _s ); }
  // MCl: it is "_s" instead of the most common "s" to avoid a fake icc remark #1599
  friend StreamBuffer& operator>>( StreamBuffer& _s, SmartRefVector<TYPE>& ptr ) { return ptr.readRefs( _s ); }
};

template <class TYPE>
inline StreamBuffer& SmartRefVector<TYPE>::writeRefs( StreamBuffer& s ) const {
  long len = _Base::size();
  s << len;
  for ( _BaseConstIter i = _Base::begin(); i != _Base::end(); i++ ) {
    ( *i )._setEnvironment( m_data, m_contd );
    ( *i ).writeRef( s );
  }
  return s;
}

template <class TYPE>
inline StreamBuffer& SmartRefVector<TYPE>::readRefs( StreamBuffer& s ) {
  long len;
  _Base::erase( _Base::begin(), _Base::end() );
  s >> len;
  for ( long i = 0; i < len; i++ ) {
    _BaseValueType entry;
    entry._setEnvironment( m_data, m_contd );
    entry.readRef( s );
    _Base::push_back( entry );
  }
  return s;
}

#endif // KERNEL_SMARTREFVECTOR_H