Reconstruction/KalFitAlg/include/KalFitAlg/KalFitList.h

Go to the documentation of this file.

//
// Directly from fzisan, useful class created by Kakuno-san
//
#ifndef KalFitList_FLAG_
#define KalFitList_FLAG_
 
// #include <alloc.h>
#include <stdlib.h>
 
template <class T> class KalFitList {
public:
  /// default constructor
  KalFitList( int length_to_alloc = 100 );
 
  /// copy constructor
  KalFitList( const KalFitList<T>& );
 
  /// destructor
  ~KalFitList();
 
  /// append an object into the end of the list
  int append( T x );
 
  /// append objects into the end of the list
  int append( const KalFitList<T>& );
 
  /// remove objects by index and returns decremented index and length
  int remove( int& );
 
  /// remove objects by index
  void remove2( int );
 
  /// replace index-th object by the object src
  void replace( int i, T src );
 
  /// delete objects by index and returns decremented index and length
  int deleteObj( int& );
 
  /// remove just last objects of the list
  void removeLast( void );
 
  /// clear lists but the allocated memory remains same
  void clear( void );
 
  /// clear lists and free memory
  void removeAll( void );
 
  /// delete all object and clear(allocated memory remains same)
  void deleteAll( void );
 
  /// re-allocate memory to reduce size
  void resize( void );
 
  /// returns a object by index
  T operator[]( unsigned i ) const;
 
  /// returns the reference of a object by index
  T& operator()( unsigned i ) const;
 
  /// returns the first object in the list
  T first( void ) const;
 
  /// returns the pointer of first object
  T* firstPtr( void ) const;
 
  /// returns the pointer of last object
  T* lastPtr( void ) const;
 
  /// returns the length of the list
  int length( void ) const;
 
private: // private data members
  int _length;
  int _remain;
  int _length_to_alloc;
  T*  _obj;
};
 
//----------------------------------------------
#ifdef KalFitList_NO_INLINE
#  define inline
#else
#  undef inline
#  define KalFitList_INLINE_DEFINE_HERE
#endif
 
#ifdef KalFitList_INLINE_DEFINE_HERE
 
template <class T>
inline KalFitList<T>::KalFitList( int length_to_alloc )
    : _length( 0 )
    , _remain( length_to_alloc )
    , _length_to_alloc( length_to_alloc )
    , _obj( (T*)malloc( length_to_alloc * sizeof( T ) ) ) {}
 
template <class T>
KalFitList<T>::KalFitList( const KalFitList<T>& src )
    : _length( src._length )
    , _remain( src._remain )
    , _length_to_alloc( src._length_to_alloc ) {
  _obj      = (T*)malloc( ( _length + _remain ) * sizeof( T ) );
  T* srcObj = src._obj;
  for ( int i = 0; i < _length; i++ ) { *( _obj + i ) = *( srcObj + i ); }
}
 
template <class T> inline KalFitList<T>::~KalFitList() { free( _obj ); }
 
template <class T> inline int KalFitList<T>::append( T src ) {
  if ( !_remain )
  {
    _obj    = (T*)realloc( _obj, ( _length + _length_to_alloc ) * sizeof( T ) );
    _remain = _length_to_alloc;
  }
  *( _obj + ( _length++ ) ) = src;
  _remain--;
  return _length;
}
 
template <class T> inline int KalFitList<T>::remove( int& iterator ) {
  *( _obj + ( iterator-- ) ) = *( _obj + ( --_length ) );
  _remain++;
  return _length;
}
 
template <class T> inline void KalFitList<T>::remove2( int iterator ) {
  *( _obj + iterator ) = *( _obj + ( --_length ) );
  _remain++;
}
 
template <class T> inline void KalFitList<T>::replace( int i, T src ) { *( _obj + i ) = src; }
 
template <class T> inline int KalFitList<T>::deleteObj( int& iterator ) {
  delete *( _obj + iterator );
  *( _obj + ( iterator-- ) ) = *( _obj + ( --_length ) );
  _remain++;
  return _length;
}
 
template <class T> inline void KalFitList<T>::removeLast( void ) {
  _length--;
  _remain++;
}
 
template <class T> inline void KalFitList<T>::clear( void ) {
  _remain += _length;
  _length = 0;
}
 
template <class T> inline void KalFitList<T>::removeAll( void ) {
  free( _obj );
  _remain = 0;
  _length = 0;
  _obj    = NULL;
}
 
template <class T> inline void KalFitList<T>::resize( void ) {
  _obj             = (T*)realloc( _obj, _length * sizeof( T ) );
  _remain          = 0;
  _length_to_alloc = _length;
}
 
template <class T> inline T KalFitList<T>::operator[]( unsigned i ) const {
  return *( _obj + i );
}
 
template <class T> inline T& KalFitList<T>::operator()( unsigned i ) const {
  return *( _obj + i );
}
 
template <class T> inline T KalFitList<T>::first( void ) const { return *_obj; }
 
template <class T> inline T* KalFitList<T>::firstPtr( void ) const { return _obj; }
 
template <class T> inline T* KalFitList<T>::lastPtr( void ) const {
  return _obj + ( _length - 1 );
}
 
template <class T> inline int KalFitList<T>::length( void ) const { return _length; }
 
template <class T> int KalFitList<T>::append( const KalFitList<T>& src ) {
  int srcLength = src._length;
  T*  srcObj    = src._obj;
  int i         = 0;
  if ( _remain < srcLength )
  {
    _obj = (T*)realloc( _obj, ( _length_to_alloc + srcLength ) * sizeof( T ) );
    while ( i ^ srcLength ) *( _obj + ( _length++ ) ) = *( srcObj + ( i++ ) );
  }
  else
  {
    while ( i ^ srcLength ) *( _obj + ( _length++ ) ) = *( srcObj + ( i++ ) );
    _remain -= srcLength;
  }
  return _length;
}
 
template <class T> void KalFitList<T>::deleteAll( void ) {
  int i = _length;
  while ( i ) delete *( _obj + ( --i ) );
  clear();
}
 
#endif
 
#undef inline
 
#endif /* KalFitList_FLAG_ */