/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AthLinks/AthLinks/ElementLinkVector.h

// Dear emacs, this is -*- c++ -*-
// $Id: ElementLinkVector.h 649074 2015-02-23 16:51:40Z krasznaa $
#ifndef ATHLINKS_ELEMENTLINKVECTOR_H
#define ATHLINKS_ELEMENTLINKVECTOR_H

// System include(s):
#include <vector>

// Local include(s):
#include "AthLinks/ElementLink.h"
#include "AthLinks/ElementLinkVectorBase.h"
#include "AthLinks/tools/selection_ns.h"

// Forward declaration(s):
ENTER_ROOT_SELECTION_NS
template< class CONTAINER >
class ElementLinkVector;
EXIT_ROOT_SELECTION_NS

template< class CONTAINER >
class ElementLinkVector : public ElementLinkVectorBase {

public:
   typedef ElementLinkVector< CONTAINER > ElemLinkVec;
   typedef ElementLink< CONTAINER > ElemLink;


   typedef ElemLink value_type;
   typedef ElemLink& reference;
   typedef const ElemLink& const_reference;
   typedef typename std::vector< ElemLink >::iterator iterator;
   typedef typename std::vector< ElemLink >::const_iterator const_iterator;
   typedef typename std::vector< ElemLink >::reverse_iterator reverse_iterator;
   typedef typename std::vector< ElemLink >::const_reverse_iterator
      const_reverse_iterator;
   typedef typename std::vector< ElemLink >::size_type size_type;



   ElementLinkVector();
   ElementLinkVector( size_type n, const ElemLink& link = ElemLink() );
   ElementLinkVector( const ElemLinkVec& parent );


   ElemLinkVec& operator=( const ElemLinkVec& rhs );


   iterator begin() { return m_elVec.begin(); }
   const_iterator begin() const { return m_elVec.begin(); }

   iterator end() { return m_elVec.end(); }
   const_iterator end() const { return m_elVec.end(); }

   reverse_iterator rbegin() { return m_elVec.rbegin(); }
   const_reverse_iterator rbegin() const { return m_elVec.rbegin(); }

   reverse_iterator rend() { return m_elVec.rend(); }
   const_reverse_iterator rend() const { return m_elVec.rend(); }



   size_type size() const { return m_elVec.size(); }
   size_type max_size() const { return m_elVec.max_size(); }
   size_type capacity() const { return m_elVec.capacity(); }
   void resize( size_type sz, const ElemLink& link = ElemLink() );
   void reserve( size_type sz ) { m_elVec.reserve( sz ); }
   bool empty() const { return ( size() == 0 ); }



   const_reference operator[]( size_type n ) const { return m_elVec[ n ]; }
   const_reference at( size_type n ) const { return m_elVec.at( n ); }
   const_reference front() const { return m_elVec.front(); }
   const_reference back() const { return m_elVec.back(); }



   void push_back( const ElemLink& el );
   void pop_back();

   iterator erase( iterator position );
   iterator erase( iterator first, iterator last );

   void swap( ElemLinkVec& vec );

   template< class InputIterator >
   void assign( InputIterator first, InputIterator last );
   void assign( size_type n, const ElemLink& link );

   iterator insert( iterator position, const ElemLink& link );
   void insert( iterator position, size_type n, const ElemLink& link );

   void clear();


   virtual bool toTransient();
   bool toPersistent();

private:
   std::vector< ElemLink > m_elVec;

   typedef typename
   ROOT_SELECTION_NS::ElementLinkVector< CONTAINER >::self DictSel;

}; // class ElementLinkVector

/*
 * This code declares that the variables of ElementLinkVector
 * are supposed to be transient in all instantiations.
 */
ENTER_ROOT_SELECTION_NS
template< class CONTAINER >
class ElementLinkVector
#if ROOT_VERSION_CODE >= ROOT_VERSION( 6, 0, 2 )
   : public SelectNoInstance
#endif // ROOT_VERSION
{

public:
   typedef ElementLinkVector< CONTAINER > self;

#if ROOT_VERSION_CODE < ROOT_VERSION( 5, 99, 0 )

   ROOT_SELECTION_NS::NO_SELF_AUTOSELECT dummy;

   ROOT_SELECTION_NS::TRANSIENT m_elVec;

#else

   ROOT_SELECTION_NS::MemberAttributes< kTransient > m_elVec;

#endif // ROOT_VERSION

};
EXIT_ROOT_SELECTION_NS

// Include the implementation:
#ifndef __GCCXML__
#   include "AthLinks/ElementLinkVector.icc"
#endif // not __GCCXML__

#endif // ATHLINKS_ELEMENTLINKVECTOR_H

---