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;
  friend StreamBuffer& operator<< (StreamBuffer& s, const SmartRefVector<TYPE>& ptr)   {
    return ptr.writeRefs(s);
  }
  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