/data/refman/pasoursint/CMSSW_6_1_2_SLHC2_patch1/src/Geometry/CaloGeometry/interface/EZArrayVL.h

Go to the documentation of this file.

#ifndef GEOMETRY_CALOGEOMETRY_EZArrayVL_H
#define GEOMETRY_CALOGEOMETRY_EZArrayVL_H 1

#include "Geometry/CaloGeometry/interface/EZMgrVL.h"

template < class T >
class EZArrayVL
{
   public:

      typedef          EZMgrVL< T >             MgrType ;
      typedef typename MgrType::iterator        iterator ;
      typedef typename MgrType::const_iterator  const_iterator ;
      typedef typename MgrType::reference       reference ;
      typedef typename MgrType::const_reference const_reference ;
      typedef typename MgrType::size_type       size_type ;
      typedef typename MgrType::value_type      value_type ;

      EZArrayVL< T >( const MgrType* mgr       , 
                      size_type      size = 0  ,
                      const T&       t    = T()  ) :
         m_begin ( 0 ) ,
         m_size  ( size ) ,
         m_mgr   ( mgr )   {}

      EZArrayVL< T >( const MgrType* mgr   , 
                      const_iterator start ,
                      const_iterator finis       ) :
         m_begin ( 0==finis-start ? (iterator)0 : mgr->assign( finis - start ) ) ,
         m_size  ( finis - start ) ,
         m_mgr   ( mgr )
      {
         assert( ( finis - start ) > 0 ) ;
         iterator i ( begin() ) ;
         for( const_iterator ic ( start ) ; ic != finis ; ++ic )
         {
            (*i) = (*ic) ;
         }
      }

      virtual ~EZArrayVL< T >() {}

      virtual void resize( size_type size ) { m_mgr->assign( size ) ; }

      virtual void assign( size_type size,
                           const T&  t = T() ) const 
      {
         assert( (iterator)0 == m_begin ) ;
         m_size = size ;
         m_begin = m_mgr->assign( size, t ) ;
      }

      const_iterator begin() const { return m_begin ; } 
      const_iterator end()   const { return m_size + m_begin ; }

      reference operator[]( const unsigned int i ) 
      {
         if( (iterator)0 == m_begin ) assign( m_size ) ;
         return *( m_begin + i ) ; 
      }

      const_reference operator[]( const unsigned int i ) const 
      {
         return *( m_begin + i ) ;
      }

      bool uninitialized() const { return ( 0 == m_begin ) ;  }

      bool empty()         const { return ( 0 == size() ) ;  }

      size_type size()     const { return ( m_end - m_begin ) ; }

      size_type capacity() const { return size() ; }

   protected:

   private:

      EZArrayVL< T >() ; //stop
      //EZArrayVL( const EZArrayVL& ) ; //stop
      //EZArrayVL& operator=( const EZArrayVL& ) ; //stop
      mutable iterator m_begin   ;
      size_type        m_size    ;
      const MgrType*   m_mgr   ;
};

#endif