#include <baseapi.h>

Inheritance diagram for GenericVector< T >:

Public Member Functions
	GenericVector ()

	GenericVector (int size)

	GenericVector (const GenericVector &other)

GenericVector< T > &	operator+= (const GenericVector &other)

GenericVector< T > &	operator= (const GenericVector &other)

virtual	~GenericVector ()

void	reserve (int size)

void	double_the_size ()

void	init_to_size (int size, T t)

int	size () const

int	length () const

bool	empty () const

T &	get (int index) const

T &	back () const

T &	operator[] (int index) const

int	get_index (T object) const

bool	contains (T object) const

T	contains_index (int index) const

int	push_back (T object)

void	operator+= (T t)

int	push_back_new (T object)

int	push_front (T object)

void	set (T t, int index)

void	insert (T t, int index)

virtual void	remove (int index)

virtual void	truncate (int size)

void	set_clear_callback (TessCallback1< T > *cb)

void	set_compare_callback (TessResultCallback2< bool, T const &, T const & > *cb)

virtual void	clear ()

void	delete_data_pointers ()

void	move (GenericVector< T > *from)

bool	write (FILE f, TessResultCallback2< bool, FILE , T const & > *cb) const

bool	read (FILE f, TessResultCallback3< bool, FILE , T , bool > cb, bool swap)

virtual bool	Serialize (FILE *fp) const

virtual bool	DeSerialize (bool swap, FILE *fp)

bool	SerializeClasses (FILE *fp) const

bool	DeSerializeClasses (bool swap, FILE *fp)

void	sort ()

void	sort (int(comparator)(const void , const void *))

bool	bool_binary_search (const T &target) const

int	binary_search (const T &target) const

void	compact_sorted ()

void	compact (TessResultCallback1< bool, int > *delete_cb)

T	dot_product (const GenericVector< T > &other) const

Static Public Member Functions
static T *	double_the_size_memcpy (int current_size, T *data)

Protected Member Functions
void	init (int size)

Protected Attributes
inT32	size_used_

inT32	size_reserved_

T *	data_

TessCallback1< T > *	clear_cb_

TessResultCallback2< bool, T const &, T const & > *	compare_cb_

Static Protected Attributes
static const int	kDefaultVectorSize = 4

Detailed Description

template<typename T>
class GenericVector< T >

Definition at line 36 of file baseapi.h.

Constructor & Destructor Documentation

template<typename T>

GenericVector< T >::GenericVector ( )

inline

Definition at line 37 of file genericvector.h.

37 { this->init(kDefaultVectorSize); }

GenericVector::kDefaultVectorSize

static const int kDefaultVectorSize

Definition: genericvector.h:273

GenericVector::init

void init(int size)

Definition: genericvector.h:461

template<typename T>

GenericVector< T >::GenericVector ( int size )

inlineexplicit

Definition at line 38 of file genericvector.h.

38 { this->init(size); }

GenericVector::init

void init(int size)

Definition: genericvector.h:461

GenericVector::size

int size() const

Definition: genericvector.h:59

template<typename T>

GenericVector< T >::GenericVector ( const GenericVector< T > & other )

inline

Definition at line 41 of file genericvector.h.

                                             {
     this->init(other.size());
     this->operator+=(other);
   }

template<typename T >

GenericVector< T >::~GenericVector ( )

virtual

Definition at line 471 of file genericvector.h.

                                  {
   clear();
 }

Member Function Documentation

template<typename T >

T & GenericVector< T >::back ( ) const

Definition at line 522 of file genericvector.h.

                                 {
   ASSERT_HOST(size_used_ > 0);
   return data_[size_used_ - 1];
 }

template<typename T>

int GenericVector< T >::binary_search ( const T & target ) const

inline

Definition at line 209 of file genericvector.h.

                                            {
     int bottom = 0;
     int top = size_used_;
     do {
       int middle = (bottom + top) / 2;
       if (data_[middle] > target)
         top = middle;
       else
         bottom = middle;
     }
     while (top - bottom > 1);
     return bottom;
   }

template<typename T>

bool GenericVector< T >::bool_binary_search ( const T & target ) const

inline

Definition at line 197 of file genericvector.h.

                                                  {
     int index = binary_search(target);
     if (index >= size_used_)
       return false;
     return data_[index] == target;
   }

template<typename T >

void GenericVector< T >::clear ( )

virtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< tesseract::TrainingSample >, tesseract::PointerVector< tesseract::Shape >, and tesseract::DawgInfoVector.

Definition at line 651 of file genericvector.h.

                              {
   if (size_reserved_ > 0) {
     if (clear_cb_ != NULL)
       for (int i = 0; i < size_used_; ++i)
         clear_cb_->Run(data_[i]);
     delete[] data_;
     data_ = NULL;
     size_used_ = 0;
     size_reserved_ = 0;
   }
   if (clear_cb_ != NULL) {
     delete clear_cb_;
     clear_cb_ = NULL;
   }
   if (compare_cb_ != NULL) {
     delete compare_cb_;
     compare_cb_ = NULL;
   }
 }

template<typename T>

void GenericVector< T >::compact ( TessResultCallback1< bool, int > * delete_cb )

inline

Definition at line 242 of file genericvector.h.

                                                           {
     int new_size = 0;
     int old_index = 0;
     // Until the callback returns true, the elements stay the same.
     while (old_index < size_used_ && !delete_cb->Run(old_index++))
       ++new_size;
     // Now just copy anything else that gets false from delete_cb.
     for (; old_index < size_used_; ++old_index) {
       if (!delete_cb->Run(old_index)) {
         data_[new_size++] = data_[old_index];
       }
     }
     size_used_ = new_size;
     delete delete_cb;
   }

template<typename T>

void GenericVector< T >::compact_sorted ( )

inline

Definition at line 225 of file genericvector.h.

                         {
     if (size_used_ == 0)
       return;
 
     // First element is in no matter what, hence the i = 1.
     int last_write = 0;
     for (int i = 1; i < size_used_; ++i) {
       // Finds next unique item and writes it.
       if (data_[last_write] != data_[i])
         data_[++last_write] = data_[i];
     }
     // last_write is the index of a valid data cell, so add 1.
     size_used_ = last_write + 1;
   }

template<typename T>

bool GenericVector< T >::contains ( T object ) const

Definition at line 579 of file genericvector.h.

                                               {
   return get_index(object) != -1;
 }

template<typename T >

T GenericVector< T >::contains_index ( int index ) const

Definition at line 562 of file genericvector.h.

                                                   {
   return index >= 0 && index < size_used_;
 }

template<typename T >

void GenericVector< T >::delete_data_pointers ( )

Definition at line 672 of file genericvector.h.

                                             {
   for (int i = 0; i < size_used_; ++i)
     if (data_[i]) {
       delete data_[i];
     }
 }

template<typename T >

bool GenericVector< T >::DeSerialize	(	bool	swap,
		FILE *	fp
	)

virtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< tesseract::TrainingSample >, and tesseract::PointerVector< tesseract::Shape >.

Definition at line 741 of file genericvector.h.

                                                       {
   inT32 reserved;
   if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
   if (swap) Reverse32(&reserved);
   reserve(reserved);
   size_used_ = reserved;
   if (fread(data_, sizeof(T), size_used_, fp) != size_used_) return false;
   if (swap) {
     for (int i = 0; i < size_used_; ++i)
       ReverseN(&data_[i], sizeof(data_[i]));
   }
   return true;
 }

template<typename T >

bool GenericVector< T >::DeSerializeClasses	(	bool	swap,
		FILE *	fp
	)

Definition at line 773 of file genericvector.h.

                                                              {
   uinT32 reserved;
   if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
   if (swap) Reverse32(&reserved);
   T empty;
   init_to_size(reserved, empty);
   for (int i = 0; i < reserved; ++i) {
     if (!data_[i].DeSerialize(swap, fp)) return false;
   }
   return true;
 }

template<typename T>

T GenericVector< T >::dot_product ( const GenericVector< T > & other ) const

inline

Definition at line 258 of file genericvector.h.

                                                      {
     T result = static_cast<T>(0);
     for (int i = MIN(size_used_, other.size_used_) - 1; i >= 0; --i)
       result += data_[i] * other.data_[i];
     return result;
   }

template<typename T >

void GenericVector< T >::double_the_size ( )

Definition at line 490 of file genericvector.h.

                                        {
   if (size_reserved_ == 0) {
     reserve(kDefaultVectorSize);
   }
   else {
     reserve(2 * size_reserved_);
   }
 }

template<typename T>

static T* GenericVector< T >::double_the_size_memcpy	(	int	current_size,
		T *	data
	)

inlinestatic

Definition at line 172 of file genericvector.h.

                                                               {
     T *data_new = new T[current_size * 2];
     memcpy(data_new, data, sizeof(T) * current_size);
     delete[] data;
     return data_new;
   }

template<typename T>

bool GenericVector< T >::empty ( ) const

inline

Definition at line 68 of file genericvector.h.

                      {
     return size_used_ == 0;
   }

template<typename T >

T & GenericVector< T >::get ( int index ) const

Definition at line 511 of file genericvector.h.

                                         {
   ASSERT_HOST(index >= 0 && index < size_used_);
   return data_[index];
 }

template<typename T>

int GenericVector< T >::get_index ( T object ) const

Definition at line 568 of file genericvector.h.

                                               {
   for (int i = 0; i < size_used_; ++i) {
     ASSERT_HOST(compare_cb_ != NULL);
     if (compare_cb_->Run(object, data_[i]))
       return i;
   }
   return -1;
 }

template<typename T >

void GenericVector< T >::init ( int size )

protected

Definition at line 461 of file genericvector.h.

                                     {
   size_used_ = 0;
   size_reserved_ = 0;
   data_ = 0;
   clear_cb_ = 0;
   compare_cb_ = 0;
   reserve(size);
 }

template<typename T>

void GenericVector< T >::init_to_size	(	int	size,
		T	t
	)

Definition at line 501 of file genericvector.h.

                                                  {
   reserve(size);
   size_used_ = size;
   for (int i = 0; i < size; ++i)
     data_[i] = t;
 }

template<typename T>

void GenericVector< T >::insert	(	T	t,
		int	index
	)

Definition at line 538 of file genericvector.h.

                                             {
   ASSERT_HOST(index >= 0 && index < size_used_);
   if (size_reserved_ == size_used_)
     double_the_size();
   for (int i = size_used_; i > index; --i) {
     data_[i] = data_[i-1];
   }
   data_[index] = t;
   size_used_++;
 }

template<typename T>

int GenericVector< T >::length ( ) const

inline

Definition at line 63 of file genericvector.h.

                      {
     return size_used_;
   }

template<typename T>

void GenericVector< T >::move ( GenericVector< T > * from )

Definition at line 788 of file genericvector.h.

                                                   {
   this->clear();
   this->data_ = from->data_;
   this->size_reserved_ = from->size_reserved_;
   this->size_used_ = from->size_used_;
   this->compare_cb_ = from->compare_cb_;
   this->clear_cb_ = from->clear_cb_;
   from->data_ = NULL;
   from->clear_cb_ = NULL;
   from->compare_cb_ = NULL;
   from->size_used_ = 0;
   from->size_reserved_ = 0;
 }

template<typename T >

GenericVector< T > & GenericVector< T >::operator+= ( const GenericVector< T > & other )

Definition at line 620 of file genericvector.h.

                                                                          {
   this->reserve(size_used_ + other.size_used_);
   for (int i = 0; i < other.size(); ++i) {
     this->operator+=(other.data_[i]);
   }
   return *this;
 }

template<typename T>

void GenericVector< T >::operator+= ( T t )

Definition at line 615 of file genericvector.h.

                                      {
   push_back(t);
 }

template<typename T >

GenericVector< T > & GenericVector< T >::operator= ( const GenericVector< T > & other )

Definition at line 629 of file genericvector.h.

                                                                         {
   this->truncate(0);
   this->operator+=(other);
   return *this;
 }

template<typename T >

T & GenericVector< T >::operator[] ( int index ) const

Definition at line 517 of file genericvector.h.

                                                {
  return data_[index];
 }

template<typename T>

int GenericVector< T >::push_back ( T object )

Definition at line 585 of file genericvector.h.

                                         {
   int index = 0;
   if (size_used_ == size_reserved_)
     double_the_size();
   index = size_used_++;
   data_[index] = object;
   return index;
 }

template<typename T>

int GenericVector< T >::push_back_new ( T object )

Definition at line 595 of file genericvector.h.

                                             {
   int index = get_index(object);
   if (index >= 0)
     return index;
   return push_back(object);
 }

template<typename T>

int GenericVector< T >::push_front ( T object )

Definition at line 604 of file genericvector.h.

                                          {
   if (size_used_ == size_reserved_)
     double_the_size();
   for (int i = size_used_; i > 0; --i)
     data_[i] = data_[i-1];
   data_[0] = object;
   ++size_used_;
   return 0;
 }

template<typename T>

bool GenericVector< T >::read	(	FILE *	f,
		TessResultCallback3< bool, FILE , T , bool > *	cb,
		bool	swap
	)

Definition at line 700 of file genericvector.h.

                                        {
   inT32 reserved;
   if (fread(&reserved, sizeof(reserved), 1, f) != 1) return false;
   if (swap) Reverse32(&reserved);
   reserve(reserved);
   if (fread(&size_used_, sizeof(size_used_), 1, f) != 1) return false;
   if (swap) Reverse32(&size_used_);
   if (cb != NULL) {
     for (int i = 0; i < size_used_; ++i) {
       if (!cb->Run(f, data_ + i, swap)) {
         delete cb;
         return false;
       }
     }
     delete cb;
   } else {
     if (fread(data_, sizeof(T), size_used_, f) != size_used_) return false;
     if (swap) {
       for (int i = 0; i < size_used_; ++i)
         ReverseN(&data_[i], sizeof(T));
     }
   }
   return true;
 }

template<typename T >

void GenericVector< T >::remove ( int index )

virtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< tesseract::TrainingSample >, and tesseract::PointerVector< tesseract::Shape >.

Definition at line 552 of file genericvector.h.

                                        {
   ASSERT_HOST(index >= 0 && index < size_used_);
   for (int i = index; i < size_used_ - 1; ++i) {
     data_[i] = data_[i+1];
   }
   size_used_--;
 }

template<typename T >

void GenericVector< T >::reserve ( int size )

Definition at line 478 of file genericvector.h.

                                        {
   if (size_reserved_ >= size || size <= 0)
     return;
   T* new_array = new T[size];
   for (int i = 0; i < size_used_; ++i)
     new_array[i] = data_[i];
   if (data_ != NULL) delete[] data_;
   data_ = new_array;
   size_reserved_ = size;
 }

template<typename T >

bool GenericVector< T >::Serialize ( FILE * fp ) const

virtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< tesseract::TrainingSample >, and tesseract::PointerVector< tesseract::Shape >.

Definition at line 730 of file genericvector.h.

                                                {
   if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) return false;
   if (fwrite(data_, sizeof(*data_), size_used_, fp) != size_used_) return false;
   return true;
 }

template<typename T >

bool GenericVector< T >::SerializeClasses ( FILE * fp ) const

Definition at line 759 of file genericvector.h.

                                                       {
   if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) return false;
   for (int i = 0; i < size_used_; ++i) {
     if (!data_[i].Serialize(fp)) return false;
   }
   return true;
 }

template<typename T>

void GenericVector< T >::set	(	T	t,
		int	index
	)

Definition at line 529 of file genericvector.h.

                                          {
   ASSERT_HOST(index >= 0 && index < size_used_);
   data_[index] = t;
 }

template<typename T>

void GenericVector< T >::set_clear_callback ( TessCallback1< T > * cb )

Definition at line 638 of file genericvector.h.

                                                               {
   clear_cb_ = cb;
 }

template<typename T>

void GenericVector< T >::set_compare_callback ( TessResultCallback2< bool, T const &, T const & > * cb )

Definition at line 645 of file genericvector.h.

                                                                                                {
   compare_cb_ = cb;
 }

template<typename T>

int GenericVector< T >::size ( ) const

inline

Definition at line 59 of file genericvector.h.

                    {
     return size_used_;
   }

template<typename T >

void GenericVector< T >::sort ( )

Definition at line 803 of file genericvector.h.

                             {
   sort(&tesseract::sort_cmp<T>);
 }

template<typename T>

void GenericVector< T >::sort ( int(*)(const void *, const void *) comparator )

inline

Definition at line 190 of file genericvector.h.

                                                          {
     qsort(data_, size_used_, sizeof(*data_), comparator);
   }

template<typename T>

virtual void GenericVector< T >::truncate ( int size )

inlinevirtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< tesseract::TrainingSample >, and tesseract::PointerVector< tesseract::Shape >.

Definition at line 112 of file genericvector.h.

                                   {
     if (size < size_used_)
       size_used_ = size;
   }

template<typename T>

bool GenericVector< T >::write	(	FILE *	f,
		TessResultCallback2< bool, FILE , T const & >	cb
	)		const

Definition at line 681 of file genericvector.h.

                                                                     {
   if (fwrite(&size_reserved_, sizeof(size_reserved_), 1, f) != 1) return false;
   if (fwrite(&size_used_, sizeof(size_used_), 1, f) != 1) return false;
   if (cb != NULL) {
     for (int i = 0; i < size_used_; ++i) {
       if (!cb->Run(f, data_[i])) {
         delete cb;
         return false;
       }
     }
     delete cb;
   } else {
     if (fwrite(data_, sizeof(T), size_used_, f) != size_used_) return false;
   }
   return true;
 }

Member Data Documentation

template<typename T>

TessCallback1<T>* GenericVector< T >::clear_cb_

protected

Definition at line 277 of file genericvector.h.

template<typename T>

TessResultCallback2<bool, T const &, T const &>* GenericVector< T >::compare_cb_

mutableprotected

Definition at line 279 of file genericvector.h.

template<typename T>

T* GenericVector< T >::data_

protected

Definition at line 276 of file genericvector.h.

template<typename T>

const int GenericVector< T >::kDefaultVectorSize = 4

staticprotected

Definition at line 273 of file genericvector.h.

template<typename T>

inT32 GenericVector< T >::size_reserved_

protected

Definition at line 275 of file genericvector.h.

template<typename T>

inT32 GenericVector< T >::size_used_

protected

Definition at line 274 of file genericvector.h.

The documentation for this class was generated from the following files:

/home/abuild/rpmbuild/BUILD/tesseract-ocr-3.02.02/api/baseapi.h
/home/abuild/rpmbuild/BUILD/tesseract-ocr-3.02.02/ccutil/genericvector.h

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

template<typename T> class GenericVector< T >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T>
class GenericVector< T >