Back to index

CList.h

 
//----------------------------------------------------------------------------- 
//  $Header: /tmp_mnt/asis/offline/ceres/cool/project/RCS/CList.h,v 2.1 1996/10/04 08:42:55 voigt Exp messer $ 
// 
//  COOL Program Library   
//  Copyright (C) CERES collaboration, 1996 
// 
//  Declaration of template class CList. 
//  This class behaves as a RWTPtrOrderedVector<T>. The internal 
//  implementation however may change for persistency. 
// 
//----------------------------------------------------------------------------- 
#ifndef CLIST_H 
#define CLIST_H 
 
#include <rw/tpordvec.h> 
#include "cool.h" 
 
template<class T> class CList { 
public: 
   CList(); 
   CList(const CList<T>&); 
   CList<T>& operator= (const CList<T>&); 
    
   virtual ~CList(); 
    
   T*&			operator()(size_t i); 
   T*const&		operator()(size_t i) const; 
    
   T*&			operator[](size_t i); 
   T*const&		operator[](size_t i) const; 
    
   void			append(T*); 
   void			insert(T*); 
   void			clear(); 
   void			clearAndDestroy(); 
   size_t		entries() const; 
   size_t		length() const; 
   T*&			first(); 
   T*const&		first() const; 
   T*&		        last(); 
   T*const&		last() const; 
   T*			removeAt(size_t); 
   CBoolean		isEmpty() const; 
    
protected: 
   RWTPtrOrderedVector<T> items; 
}; 
 
 
template<class T> inline CList<T>::CList() { /* nop */ } 
 
template<class T> inline CList<T>::CList(const CList<T>& lis)  
{ 
   items = lis.items; 
} 
 
template<class T> inline CList<T>& CList<T>::operator= (const CList<T>& lis) 
{ 
   if (&lis != this) items = lis.items; 
   return *this; 
} 
 
template<class T> inline CList<T>::~CList() 
{ 
   items.clearAndDestroy(); 
} 
 
template<class T> inline T*& CList<T>::operator()(size_t i) 
{ 
   return items(i); 
} 
 
template<class T> inline T*const& CList<T>::operator()(size_t i) const 
{ 
   return items(i); 
} 
    
template<class T> inline T*& CList<T>::operator[](size_t i) 
{ 
   return items[i]; 
} 
 
template<class T> inline T*const& CList<T>::operator[](size_t i) const 
{ 
   return items[i]; 
} 
    
template<class T> inline void CList<T>::append(T* item) 
{ 
   items.append(item); 
} 
 
template<class T> inline void CList<T>::insert(T* item) 
{ 
   items.insert(item); 
} 
 
template<class T> inline void CList<T>::clear() 
{ 
   items.clear(); 
} 
 
template<class T> inline void CList<T>::clearAndDestroy() 
{ 
   items.clearAndDestroy(); 
} 
 
template<class T> inline size_t CList<T>::entries() const 
{ 
   return items.entries(); 
} 
 
template<class T> inline size_t CList<T>::length() const 
{ 
   return items.length(); 
} 
 
template<class T> inline T*& CList<T>::first() 
{ 
   return items.first(); 
} 
 
template<class T> inline T*const& CList<T>::first() const 
{ 
   return items.first(); 
} 
    
template<class T> inline T*& CList<T>::last() 
{ 
   return items.last(); 
} 
    
template<class T> inline T*const& CList<T>::last() const 
{ 
   return items.last(); 
} 
       
template<class T> inline T* CList<T>::removeAt(size_t i) 
{ 
   return items.removeAt(i); 
} 
 
template<class T> inline CBoolean CList<T>::isEmpty() const 
{ 
   return items.isEmpty(); 
} 
 
#ifdef RW_COMPILE_INSTANTIATE 
// does not yet exist: #include "CList.C" 
#endif 
 
#endif /* CLIST_H */ 

Back to index