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