SmartRefVector.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
//  ====================================================================
//  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>
 
// forward declare _object and PyObject to avoid including Python.h here
struct _object;
namespace SmartRefVectorImpl {
  using PyObject = _object;
  // Avoid leaking the below into global namespace
  struct SmartRefVectorPythonizer {
    // newer PyROOT will map SmartRefVector<TYPE>& operator()( ContainedObject* pObj )
    // to "__getitem__" deleting it via this callback will make `__getitem__` call
    //  the operator [] from the base class
    //  see e.g. https://github.com/root-project/root/issues/7179
    static void __cppyy_pythonize__( PyObject* klass, const std::string& name );
  };
} // namespace SmartRefVectorImpl
 
template <class TYPE>
class SmartRefVector : public std::vector<SmartRef<TYPE>>, SmartRefVectorImpl::SmartRefVectorPythonizer {
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:
  using SmartRefVectorPythonizer::__cppyy_pythonize__;
 
  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