A/AthLinks/ElementLinkVector.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
/*
 Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
#ifndef ATHLINKS_ELEMENTLINKVECTOR_H
#define ATHLINKS_ELEMENTLINKVECTOR_H
 
// System include(s):
#include <vector>
#include <RootMetaSelection.h>
 
// Local include(s):
#include "AthLinks/ElementLink.h"
#include "AthLinks/ElementLinkVectorBase.h"
 
// Forward declaration(s):
namespace ROOT { namespace Meta { namespace Selection {
  template< class CONTAINER >
  class ElementLinkVector;
}}}
 
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 );
 
   bool operator==( const ElementLinkVector& rhs ) const;
   bool operator!=( const ElementLinkVector& rhs ) const;
 
 
   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::Meta::Selection::ElementLinkVector< CONTAINER >::self DictSel;
 
}; // class ElementLinkVector
 
/*
 * This code declares that the variables of ElementLinkVector
 * are supposed to be transient in all instantiations.
 */
namespace ROOT { namespace Meta { namespace Selection {
template< class CONTAINER >
class ElementLinkVector : public SelectNoInstance
{
 
public:
   typedef ElementLinkVector< CONTAINER > self;
 
   ROOT::Meta::Selection::MemberAttributes< kTransient > m_elVec;
 
};
}}} // ROOT namespace
 
// Include the implementation:
#ifndef __GCCXML__
#   include "AthLinks/ElementLinkVector.icc"
#endif // not __GCCXML__
 
#endif // ATHLINKS_ELEMENTLINKVECTOR_H