Event/GeneratorObject/include/DataModel/ElementLinkVector.h

Go to the documentation of this file.

#ifndef DATAMODEL_ELEMENTLINKVECTOR_H
#define DATAMODEL_ELEMENTLINKVECTOR_H
 
#ifndef DATAMODEL_DATALINK_H
#  include "DataModel/DataLink.h"
#endif
 
#ifndef DATAMODEL_ELEMENTLINK_H
#  include "DataModel/ElementLink.h"
#endif
 
#ifndef _CPP_ALGORITHM
#  include <algorithm>
#endif
#ifndef __EXCEPTION__
#  include <exception>
#endif
#ifndef _CPP_FUNCTIONAL
#  include <functional>
#endif
#ifndef _CPP_VECTOR
#  include <vector>
#endif
#ifndef BOOST_ITERATOR_ADAPTOR_DWA053000_HPP_
#  include <boost/iterator_adaptors.hpp>
#endif
 
/** @class ElementLinkVector
 * @brief a vector of "compact" element links. It turns the host data object
 * key into an index. The memory size of a compact link is three
 * words/link, and only 2 words/link needs to be persistified.
 * It also mantains a vector of hosts used to generate the "short ref"
 *
 * @param DOBJ        host object type (e,g. vector<Elem>, NOT Elem),
 * All host data objects must have the same type.
 * @param StoragePolicy   DOBJ management policy (defaults to DataProxyStorage)
 * @param IndexingPolicy  policy to find the element in the host DOBJ \n
 * IndexingPolicy is generated automatically for STL sequences
 * (e.g. vector, DataList etc). For other types of containers
 * (e.g. maps), the container author must define the container type
 * using the macros in tools/DeclareIndexingPolicies.h \n
 * Advanced developers may have to define an ad-hoc indexing policy
 * (e.g. GenParticleIndexing in GeneratorObjects/McEventIndexingPolicy.h)
 *
 * @author ATLAS Collaboration
 * $Id: ElementLinkVector.h,v 1.3 2003/10/20 08:18:58 srini Exp $
 **/
 
template <typename DOBJ, class StoragePolicy = DataProxyStorage<DOBJ>,
          class IndexingPolicy = typename SG::GenerateIndexingPolicy<DOBJ>::type>
class ElementLinkVector {
private:
  typedef typename std::vector<DataLink<DOBJ, StoragePolicy>>    DataLinkVector;
  typedef ElementLink<DOBJ, StoragePolicy, IndexingPolicy>       ElemLink;
  typedef ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy> ElemLinkVec;
 
  /** @class ElemLinkRef
   *  @brief a short ref to an ElementLink into an ElementLinkVector
   */
  class ElemLinkRef : public IndexingPolicy {
  public:
    typedef ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy> ElemLinkVec;
    typedef typename ElemLinkVec::ElemLink                         ElemLink;
    typedef typename ElemLink::ElementPointer                      ElementPointer;
    typedef typename ElemLink::ElementConstPointer                 ElementConstPointer;
    typedef typename ElemLink::index_type                          index_type;
    typedef typename ElemLink::ID_type                             ID_type;
 
    /// STL required
    ElemLinkRef( const ElemLinkRef& rhs );
    /// STL required
    ElemLinkRef& operator=( const ElemLinkRef& rhs );
    /// standard constructor
    ///  @throws invalid_argument when link not found in ElemLinkVector
    ElemLinkRef( const ElemLinkVec& linkVect, const ElemLink& link = ElemLink() );
    /// index into the host
    using IndexingPolicy::index;
    /// dataID of the host
    ID_type dataID() const;
    /// element pointer in ElementLink
    ElementConstPointer cptr() const { return m_ptr; }
    /// index of an element dobj in its ElementLinkVector host dobjs list
    typename DataLinkVector::size_type shortRef() const { return m_shortRef; }
 
    /// get the corresponding ElementLink. O(1)
    ElemLink elementLink() const { return ElemLink( dataID(), index(), m_ptr ); }
 
    /// \name comparison ops (STL required)
    //@{
    bool operator==( const ElemLinkRef& rhs ) const {
      return ( ( index() == rhs.index() ) && ( dataID() == rhs.dataID() ) );
    }
    bool operator<( const ElemLinkRef& rhs ) const {
      return ( ( index() < rhs.index() ) ||
               ( ( index() == rhs.index() ) && ( dataID() < rhs.dataID() ) ) );
    }
    //@}
  private:
    ElemLinkVec & m_linkVect;                      ///! our owner
    ElementPointer                     m_ptr;      ///! the element pointer
    typename DataLinkVector::size_type m_shortRef; ///! index of the host dobj
  };
 
  /** @class Short2LongRef
   *  @brief a functor turning an ElemLinkRef into an ElementLink
   */
  struct Short2LongRef : public std::unary_function<ElemLinkRef, ElemLink> {
    ElemLink operator()( const ElemLinkRef& shortRef ) const { return shortRef.elementLink(); }
  };
 
  /// the element links stored as ElemLinkRefs for compactness
  typedef typename std::vector<ElemLinkRef> RefVector;
  RefVector                                 m_shortRefs;
 
  /// the dobjs hosting our elements. They are all of type DOBJ
  DataLinkVector m_hostDObjs;
 
public:
  typedef typename ElemLink::ElementConstPointer ElementConstPointer;
  typedef typename ElemLink::index_type          index_type;
  typedef typename ElemLink::ID_type             ID_type;
 
  ///\name vector typedefs: it behaves like a vector<ElemLink>
  //@{
  typedef ElemLink& reference;
  // FIXME  typedef const ElemLink& const_reference;
  typedef ElemLink const_reference;
  typedef typename boost::transform_iterator_generator<
      Short2LongRef, typename RefVector::iterator>::type iterator;
  typedef typename boost::transform_iterator_generator<
      Short2LongRef, typename RefVector::const_iterator>::type const_iterator;
  typedef typename RefVector::size_type                        size_type;
  typedef typename RefVector::difference_type                  difference_type;
  typedef ElemLink                                             value_type;
  typedef typename RefVector::allocator_type                   allocator_type;
  typedef ElemLink*                                            pointer;
  typedef const ElemLink*                                      const_pointer;
  typedef typename boost::transform_iterator_generator<
      Short2LongRef, typename RefVector::reverse_iterator>::type reverse_iterator;
  typedef typename boost::transform_iterator_generator<
      Short2LongRef, typename RefVector::const_reverse_iterator>::type const_reverse_iterator;
  //@}
 
  /// \name recommended (fast) access to contents of ElemLinks
  /// by-pass the expensive creation of ElemLinks
  //@{
  /// pointer to an element, given its ElementLinkVector index. O(1)
  ElementConstPointer elementCPtr( size_type index ) const {
    return m_shortRefs[index].cptr();
  }
  /// host index of an element, given its ElementLinkVector index. O(1)
  index_type elementIndex( size_type index ) const { return m_shortRefs[index].index(); }
  /// dataID (long ref) of an element, given its ElementLinkVector index. O(1)
  ID_type elementDataID( size_type index ) const { return m_shortRefs[index].dataID(); }
 
  /// index of an element dobj in its ElementLinkVector host dobjs list . O(1)
  typename DataLinkVector::size_type elementShortRef( size_type index ) const {
    return m_shortRefs[index].shortRef();
  }
  //@}
 
  /// \name iterators to DataLinkVector of host dobjs. Use e.g. for persistency
  //@{
  typename DataLinkVector::iterator       beginHostDObjs() { return m_hostDObjs.begin(); }
  typename DataLinkVector::iterator       endHostDObjs() { return m_hostDObjs.end(); }
  typename DataLinkVector::const_iterator beginHostDObjs() const {
    return m_hostDObjs.begin();
  }
  typename DataLinkVector::const_iterator endHostDObjs() const { return m_hostDObjs.end(); }
  /// find the host of an element. Returns endHostDObjs() if not found
  typename DataLinkVector::const_iterator findHostDObj( const ElemLink& link ) const;
  /// find the host of an element. Returns endHostDObjs() if not found
  typename DataLinkVector::iterator findHostDObj( const ElemLink& link );
 
  //@}
 
  /// \name vector structors (no Allocators)
  //@{
  ElementLinkVector() {}
 
  ElementLinkVector( size_type n, const ElemLink& link = ElemLink() )
      : m_shortRefs( n, ElemLinkRef( *this, link ) ) {
    addHostDObj( link );
  }
 
  ElementLinkVector( int n, const ElemLink& link = ElemLink() )
      : m_shortRefs( n, ElemLinkRef( *this, link ) ) {
    addHostDObj( link );
  }
 
  ElementLinkVector( long n, const ElemLink& link = ElemLink() )
      : m_shortRefs( n, ElemLinkRef( *this, link ) ) {
    addHostDObj( link );
  }
 
  explicit ElementLinkVector( size_type n ) : m_shortRefs( n, ElemLinkRef( *this ) ) {}
 
  ElementLinkVector( const ElemLinkVec& vec )
      : m_shortRefs( vec.m_shortRefs ), m_hostDObjs( vec.m_hostDObjs ) {}
 
  template <class InputIterator> void assign( InputIterator first, InputIterator last ) {
    clear();
    insert( begin(), first, last );
  }
  void assign( size_type n, const ElemLink& link ) {
    clear();
    insert( begin(), n, link );
  }
  //@}
 
  /// \name vector iterators
  //@{
 
  iterator       begin() { return iterator( m_shortRefs.begin(), Short2LongRef() ); }
  const_iterator begin() const {
    return const_iterator( m_shortRefs.begin(), Short2LongRef() );
  }
  iterator         end() { return iterator( m_shortRefs.end(), Short2LongRef() ); }
  const_iterator   end() const { return const_iterator( m_shortRefs.end(), Short2LongRef() ); }
  reverse_iterator rbegin() {
    return reverse_iterator( m_shortRefs.begin(), Short2LongRef() );
  }
  const_reverse_iterator rbegin() const {
    return const_reverse_iterator( m_shortRefs.begin(), Short2LongRef() );
  }
  reverse_iterator rend() { return reverse_iterator( m_shortRefs.end(), Short2LongRef() ); }
  const_reverse_iterator rend() const {
    return const_reverse_iterator( m_shortRefs.end(), Short2LongRef() );
  }
  //@}
 
  /// \name vector capacity
  //@{
  size_type size() const { return m_shortRefs.size(); }
  size_type max_size() const { return m_shortRefs.max_size(); }
  void      resize( size_type sz, ElemLink& link );
  size_type capacity() const { return m_shortRefs.capacity(); }
  bool      empty() const { return 0 == size(); }
  void      reserve( size_type n ) { return m_shortRefs.reserve( n ); }
  //@}
 
  /// \name vector element accessors. NB only CONST accessors
  //@{
  // reference operator[](size_type n);
  const_reference operator[]( size_type n ) const { return m_shortRefs[n].elementLink(); }
  // reference at(size_type n);
  const_reference at( size_type n ) const { return m_shortRefs.at( n ).elementLink(); }
  // reference front();
  const_reference front() const { return m_shortRefs.front().elementLink(); }
  // reference back();
  const_reference back() const { return m_shortRefs.back().elementLink(); }
  //@}
 
  /// \name vector Modifiers
  //@{
  void push_back( const ElemLink& link ) {
    addHostObj( link );
    m_shortRefs.push_back( ElemLinkRef( *this, link ) );
  }
  void pop_back() { // FIXME CHECK
    removeHostObj( back() );
    m_shortRefs.pop_back();
  }
 
  iterator insert( iterator position, const ElemLink& link );
  void     insert( iterator position, size_type n, const ElemLink& link );
 
  iterator erase( iterator position );
  iterator erase( iterator first, iterator last );
 
  void swap( ElemLinkVec& vec ) {
    m_hostDObjs.swap( vec.m_hostDObjs );
    m_shortRefs.swap( vec.m_shortRefs );
  }
 
  void clear() {
    m_hostDObjs.clear();
    m_shortRefs.clear();
  }
  //@}
 
private:
  /// remove host of link from list. O(N) in m_hostDObjs (which is small)
  void removeHostObj( const ElemLink&
#ifdef __ELVDEBUG
                          link
#endif
  ) {
#ifdef __ELVDEBUG
    std::cout << "DUMMY removeHostDObj called for link  " << link.dataID() << "/"
              << link.index() << std::endl;
#endif
    // FIXME this is a dummy until we find how to remove an host w/o
    // FIXME screwing up the otherElemLinkRefs
    // FIXME    m_hostDObjs.erase(findHostDObj(link));
  }
 
  /// add host of link to list. No duplicates. O(N) in m_hostDObjs
  void addHostObj( const ElemLink& link ) {
    if ( endHostDObjs() == findHostDObj( link ) )
    {
      m_hostDObjs.push_back( DataLink<DOBJ, StoragePolicy>( link.dataID() ) );
#ifdef __ELVDEBUG
      std::cout << "addHostDObj added link  " << link.dataID() << "/" << link.index()
                << std::endl;
#endif
    }
  }
  /// get a short ref iterator from an iterator
  typename RefVector::const_iterator shortIterFromLong( const_iterator longIter ) const {
    typename RefVector::const_iterator ret( m_shortRefs.begin() );
    advance( ret, distance( begin(), longIter ) );
#ifdef __ELVDEBUG
    std::cout << "shortIterFromLong(const version) called for " << longIter->dataID() << "/"
              << longIter->index() << "     advance by  " << distance( begin(), longIter )
              << " result is    " << ret->dataID() << "/" << ret->index() << std::endl;
#endif
    return ret;
  }
 
  /// get a short ref iterator from an iterator
  typename RefVector::iterator shortIterFromLong( iterator longIter ) {
    typename RefVector::iterator ret( m_shortRefs.begin() );
    advance( ret, distance( begin(), longIter ) );
#ifdef __ELVDEBUG
    std::cout << "shortIterFromLong called for " << longIter->dataID() << "/"
              << longIter->index() << " advance by  " << distance( begin(), longIter )
              << " result is " << ret->dataID() << "/" << ret->index() << std::endl;
#endif
    return ret;
  }
 
  /// \name FIXME don't know how to implement
  //@{
  template <class InputIterator> ElementLinkVector( InputIterator first, InputIterator last );
  template <class InputIterator>
  void insert( iterator position, InputIterator first, InputIterator last );
  //@}
 
  /// access m_shortRefs
  friend bool operator== <>( const ElemLinkVec&, const ElemLinkVec& );
  /// access m_shortRefs
  friend bool operator< <>( const ElemLinkVec&, const ElemLinkVec& );
};
 
#ifndef STOREGATE_ELEMENTLINKVECTOR_HH
#  include "DataModel/ElementLinkVector.icc"
#endif
 
/// \name vector comparison operators
//@{
template <typename DOBJ, class StoragePolicy, class IndexingPolicy>
bool operator<( const ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& lhs,
                const ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& rhs ) {
  return ( lhs.m_shortRefs < rhs.m_shortRefs );
}
template <typename DOBJ, class StoragePolicy, class IndexingPolicy>
bool operator>( const ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& lhs,
                const ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& rhs ) {
  return rhs > lhs;
}
template <typename DOBJ, class StoragePolicy, class IndexingPolicy>
bool operator==( const ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& lhs,
                 const ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& rhs ) {
  return ( lhs.m_shortRefs == rhs.m_shortRefs );
}
template <typename DOBJ, class StoragePolicy, class IndexingPolicy>
bool operator!=( const ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& lhs,
                 const ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& rhs ) {
  return !operator==( lhs, rhs );
}
// FIXME ops <= , => etc
//@}
 
/// specialized swap algorithm
template <typename DOBJ, class StoragePolicy, class IndexingPolicy>
void std::swap( ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& lhs,
                ElementLinkVector<DOBJ, StoragePolicy, IndexingPolicy>& rhs ) {
#ifdef __ELVDEBUG
  std::cout << "std::swap called for lhs " << std::hex << &lhs << " rhs " << &rhs << std::dec
            << std::endl;
#endif
  lhs.swap( rhs );
}
#endif /*ELEMENTLINKVECTOR_H*/