Event/GeneratorObject/include/DataModel/DataVector.h

Go to the documentation of this file.

#ifndef DATAMODEL_DATAVECTOR_H
#define DATAMODEL_DATAVECTOR_H
 
#ifndef _CPP_VECTOR
#  include <vector>
#endif
#ifndef _CPP_ITERATOR
#  include <iterator>
#endif
#ifndef _CPP_ALGORITHM
#  include <algorithm> /* std::swap, advance */
#endif
#ifndef _CPP_IOSTREAM
#  include <iostream>
#endif
 
#include <typeinfo>
 
#ifndef DATAMODEL_OWNERSHIPPOLICY_H
#  include "DataModel/OwnershipPolicy.h"
#endif
 
#ifndef BOOST_CONCEPT_CHECKS_HPP
#  include <boost/concept_check.hpp>
#endif
 
#ifndef GAUDIKERNEL_SYSTEM_H
#  include "GaudiKernel/System.h"
#endif
 
namespace detail {
 
  class CompareAndPrint {
  public:
    CompareAndPrint( bool quiet ) : m_quiet( quiet ) {}
    template <typename Element> bool operator()( Element* f, Element* s ) const {
      bool areEq( f == s );
      if ( !m_quiet && areEq && f != 0 )
      {
        std::cout << "WARNING: duplicated pointer found in a DataVector of "
                  << System::typeinfoName( typeid( *f ) ) << " owning its elements! "
                  << std::hex << f << std::dec << std::endl;
      }
      return areEq;
    }
 
  private:
    bool m_quiet;
  };
 
#ifndef NDEBUG
#  define DEFQUIET false
#else
#  define DEFQUIET true
#endif
  template <class ForwIter>
  ForwIter remove_duplicates( ForwIter b, ForwIter e, bool quiet = DEFQUIET ) {
    std::sort( b, e );
    return std::unique( b, e, CompareAndPrint( quiet ) );
  }
#undef DEFQUIET
} // namespace detail
 
/** @class DataVector
 * @brief  an STL vector of pointers that by default owns
 *         its pointed elements.
 *
 *   Beware of ownership issues when you modify a DataVector.
 *  Obviously you should not delete explicitly a DataVector element.
 *   A DataVector should never have two elements pointing to the same object.
 *  This may seem obvious but certain std algorithms (e.g. remove_if) may
 *  leave a  DataVector with two copies of the same element in the
 *  "left-over" range. To avoid a crash when clearing the vector (e.g. in the
 *  destructor we have introduced a n-log(n) helper function that searches
 *  and removes duplicates in the DataVector. This is used by the destructor
 *  by clear() and by erase(first, last). As this may change in the future
 *  to improve performance, do not rely on this functionality and do avoid
 *  introducing duplicated elements in a DataVector.
 *
 *   All these cautions do not apply when a DataVector it is created with
 *  the flag SG::VIEW_ELEMENTS (see enum OwnershipPolicy) and hence does
 *  not own its elements. This is typically used to have DataVector
 *  elements allocated by DataPool. Othewise consider the cleaner
 *  alternative of using a vector<T*>
 *
 *    Notice the use of value_type instead of const_reference:
 *   this is justified by the fact that the elem are always ptrs.
 * @author ATLAS Collaboration
 *$Id: DataVector.h,v 1.17 2003/10/14 18:56:42 calaf Exp $
 */
template <typename T> class DataVector {
private:
#ifndef __ATLAS_SEAL_DICT__
  SG::OwnershipPolicy m_ownPolicy;
#else
  int m_ownPolicy;
#endif
  typedef std::vector<T*> PtrVector;
 
  PtrVector m_pCont;
 
public:
  /// access the underlying std vector;
  const PtrVector& stdcont() const { return m_pCont; }
 
  ///\name vector typedefs: it behaves like a vector<T*>
  //@{
  typedef T*&                                        reference;
  typedef const T*&                                  const_reference;
  typedef typename PtrVector::iterator               iterator;
  typedef typename PtrVector::const_iterator         const_iterator;
  typedef typename PtrVector::size_type              size_type;
  typedef typename PtrVector::difference_type        difference_type;
  typedef T*                                         value_type;
  typedef typename PtrVector::allocator_type         allocator_type;
  typedef T**                                        pointer;
  typedef const T**                                  const_pointer;
  typedef typename PtrVector::reverse_iterator       reverse_iterator;
  typedef typename PtrVector::const_reverse_iterator const_reverse_iterator;
  //@}
 
public:
  /// \name vector structors (no Allocators). Own elements by default
  //@{
  explicit DataVector( SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS )
      : m_ownPolicy( ownPolicy ), m_pCont() {}
 
  /// Non standard: always set elements to 0
  explicit DataVector( size_type           n, /* value_type pElem = 0,*/
                       SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS )
      : m_ownPolicy( ownPolicy ) {
    // FIXME what is the right thing to do?
    //   boost::function_requires< boost::DefaultConstructibleConcept<T> >();
    //   if (m_ownPolicy == SG::OWN_ELEMENTS && 0 == pElem) pElem = new T();
    insert( begin(), n, 0 );
  }
 
  /// copy constructor: since it is a shallow copy
  /// the copy DataVector does not own the elements
  explicit DataVector( const DataVector<T>& rhs )
      : m_ownPolicy( SG::VIEW_ELEMENTS ), m_pCont( rhs.stdcont() ) {
    //    cout << "copy const called"  << this << " <- " << &rhs << endl;
  }
 
  /// copy via iterators: since it is a shallow copy
  /// the copy DataVector does not own the elements
  template <class InputIterator>
  DataVector( InputIterator first, InputIterator last,
              SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS )
      : m_ownPolicy( ownPolicy ), m_pCont( first, last ) {}
 
  /// op =: since it is a shallow copy
  /// the copy DataList does not own the elements
  DataVector<T>& operator=( const DataVector<T>& rhs ) {
    m_ownPolicy = SG::VIEW_ELEMENTS;
    m_pCont     = rhs.stdcont();
    //    cout << "op = called" << this << " = " << &rhs << endl;
    return *this;
  }
 
  /// the ownership policy will determine who owns the assigned elements
  template <class InputIterator> void assign( InputIterator first, InputIterator last ) {
    clear();
    insert( begin(), first, last );
  }
 
  /// Deletes the pointed-at elements when m_ownPolicy == SG::OWN_ELEMENTS
  ///  (i.e. by default).
  virtual ~DataVector<T>() {
    if ( m_ownPolicy == SG::OWN_ELEMENTS )
    {
      iterator new_end( detail::remove_duplicates( begin(), end() ) );
      iterator iter( begin() );
      while ( iter != new_end ) delete *( iter++ );
    }
  }
  //@}
 
  /// \name vector iterators
  //@{
#define FUNFWD( func )                                                                        \
  func() { return m_pCont.func(); }
#define CONSTFUNFWD( func )                                                                   \
  func() const { return m_pCont.func(); }
#define FUNFWDN( func )                                                                       \
  func( size_type n ) { return m_pCont.func( n ); }
#define CONSTFUNFWDN( func )                                                                  \
  func( size_type n ) const { return m_pCont.func( n ); }
 
  iterator       FUNFWD( begin );
  const_iterator CONSTFUNFWD( begin );
  iterator       FUNFWD( end );
  const_iterator CONSTFUNFWD( end );
  iterator       FUNFWD( rbegin );
  const_iterator CONSTFUNFWD( rbegin );
  iterator       FUNFWD( rend );
  const_iterator CONSTFUNFWD( rend );
  //@}
 
  /// \name vector capacity
  //@{
  size_type CONSTFUNFWD( size );
  size_type CONSTFUNFWD( max_size );
 
  /// Non standard. When increasing size always set the new elements to 0
  void resize( size_type sz /*, value_type pElem = 0*/ ) {
    if ( sz < size() ) { erase( begin() + sz, end() ); }
    else
    {
      // FIXME what is the right thing to do?
      //   boost::function_requires< boost::DefaultConstructibleConcept<T> >();
      //   if (m_ownPolicy == SG::OWN_ELEMENTS && 0 == pElem) pElem = new T();
      insert( end(), sz - size(), 0 );
    }
  }
  size_type CONSTFUNFWD( capacity );
  bool      CONSTFUNFWD( empty );
  void      FUNFWDN( reserve );
  //@}
 
  /// Allows us to distinguish among read/write access to a returned reference.
  /// Manages memory correctly for lvalue references
  class ElementProxy {
  public:
    ElementProxy( PtrVector& cont, size_type index ) : m_proxied( cont.begin() ) {
      std::advance( m_proxied, index );
    }
    ElementProxy( iterator iter ) : m_proxied( iter ) {}
    /// lvalue uses assignment
    ElementProxy& operator=( const ElementProxy& rhs ) {
      delete *m_proxied;
      *m_proxied = *( rhs.m_proxied );
      return *this;
    }
    /// lvalue uses assignment
    ElementProxy& operator=( value_type rhs ) {
      delete *m_proxied;
      *m_proxied = rhs;
      return *this;
    }
    /// rvalue uses conversion
    operator T* const() const { return *m_proxied; }
 
  private:
    iterator m_proxied;
  };
 
  /// \name vector accessors. Non standard return values!
  //@{
 
  /// standard return value is reference!
  ElementProxy operator[]( size_type n ) { return ElementProxy( m_pCont, n ); }
  ElementProxy at( size_type n ) { return ElementProxy( m_pCont, n ); }
  ElementProxy front() { return ElementProxy( m_pCont.begin() ); }
  ElementProxy back() { return ElementProxy( m_pCont.end() - 1 ); }
 
  /// standard return value is const_reference i.e. const T*&!
  const T* CONSTFUNFWDN( operator[] );
  const T* CONSTFUNFWDN( at );
  const T* CONSTFUNFWD( front );
  const T* CONSTFUNFWD( back );
 
  //@}
 
  /// \name vector modifiers
  //@{
  // std  void push_back(const_reference pElem)
  void push_back( value_type pElem ) { m_pCont.push_back( pElem ); }
  void FUNFWD( pop_back );
  /// the ownership policy will determine who owns the inserted elements
  iterator insert( iterator position, value_type pElem ) { // std const_ref
    return m_pCont.insert( position, pElem );
  }
 
  /// the ownership policy will determine who owns the inserted elements
  template <class InputIterator>
  void insert( iterator position, InputIterator first, InputIterator last ) {
    m_pCont.insert( position, first, last );
  }
  /// the ownership policy will determine whether to erase the pointee
  iterator erase( iterator position ) {
    if ( m_ownPolicy == SG::OWN_ELEMENTS && position != end() ) delete position;
    return m_pCont.erase( position );
  }
  /// the ownership policy will determine whether to erase the pointee
  iterator erase( iterator first, iterator last ) {
    if ( first == last ) return first;
    if ( m_ownPolicy == SG::OWN_ELEMENTS )
    {
      iterator new_end( detail::remove_duplicates( first, last ) );
      iterator iter( first );
      while ( iter != new_end ) delete *( iter++ );
    }
    return m_pCont.erase( first, last );
  }
  void swap( DataVector<T>& rhs ) {
    std::swap( m_ownPolicy, rhs.m_ownPolicy );
    m_pCont.swap( rhs.m_pCont );
  }
  void clear() { erase( begin(), end() ); }
  //@}
 
private:
  /// \name Non standard: clieant not allowed to call as they produce
  /// unpredictable results (multiple elements pointing to the same obj)
  void assign( size_type n, value_type pElem ) {
    clear();
    insert( begin(), n, pElem );
  }
  void insert( iterator position, size_type n, value_type pElem ) { // std const_ref
    //     if (m_ownPolicy == SG::OWN_ELEMENTS) {
    //       PtrVector buf;
    //       buf.reserve(n);
    //       buf.push_back(pElem); //take ownership of the original ptr
    //       boost::function_requires< boost::CopyConstructibleConcept<T> >();
    //       for (size_type i(1); i<n; ++i) buf.push_back(pElem ? new T(*pElem) : 0);
    //       insert(position, buf.begin(), buf.end());
    //     } else {
    m_pCont.insert( position, n, pElem );
    //    }
  }
 
#undef FUNFWD
#undef CONSTFUNFWD
#undef FUNFWDN
#undef CONSTFUNFWDN
};
 
/// \name vector comparison operators
//@{
#define COMPOP( oper )                                                                        \
  template <class T> bool operator oper( const DataVector<T> lhs, const DataVector<T> rhs ) { \
    return lhs.stdcont() oper rhs.stdcont();                                                  \
  }
 
COMPOP( == )
COMPOP( < )
COMPOP( != )
COMPOP( > )
COMPOP( >= )
COMPOP( <= )
 
#undef COMPOP
 
template <class T> void swap( DataVector<T> lhs, DataVector<T> rhs ) { lhs.swap( rhs ); }
//@}
 
#endif