#include <baseapi.h>

Inheritance diagram for GenericVector< T >:

Public Member Functions
	GenericVector ()

	GenericVector (int size, T init_val)

	GenericVector (const GenericVector &other)

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

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

	~GenericVector ()

void	reserve (int size)

void	double_the_size ()

void	init_to_size (int size, T t)

void	resize_no_init (int size)

int	size () const

int	size_reserved () const

int	length () const

bool	empty () const

T &	get (int index) const

T &	back () const

T &	operator[] (int index) const

T	pop_back ()

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)

void	remove (int index)

void	truncate (int size)

void	set_clear_callback (TessCallback1< T > *cb)

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

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)

bool	Serialize (FILE *fp) const

bool	Serialize (tesseract::TFile *fp) const

bool	DeSerialize (bool swap, FILE *fp)

bool	DeSerialize (bool swap, tesseract::TFile *fp)

bool	SerializeClasses (FILE *fp) const

bool	SerializeClasses (tesseract::TFile *fp) const

bool	DeSerializeClasses (bool swap, FILE *fp)

bool	DeSerializeClasses (bool swap, tesseract::TFile *fp)

void	reverse ()

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

int	choose_nth_item (int target_index)

void	swap (int index1, int index2)

bool	WithinBounds (const T &rangemin, const T &rangemax) const

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

Protected Member Functions
int	choose_nth_item (int target_index, int start, int end, unsigned int *seed)

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>
singleton GenericVector< T >

Definition at line 41 of file baseapi.h.

Constructor & Destructor Documentation

template<typename T>

GenericVector< T >::GenericVector ( )

inline

Definition at line 40 of file genericvector.h.

                   {
     init(kDefaultVectorSize);
   }

template<typename T>

GenericVector< T >::GenericVector	(	int	size,
		T	init_val
	)

inline

Definition at line 43 of file genericvector.h.

                                       {
     init(size);
     init_to_size(size, init_val);
   }

template<typename T>

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

inline

Definition at line 49 of file genericvector.h.

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

template<typename T >

GenericVector< T >::~GenericVector ( )

Definition at line 616 of file genericvector.h.

                                  {
   clear();
 }

Member Function Documentation

template<typename T >

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

Definition at line 668 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 238 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 226 of file genericvector.h.

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

template<typename T>

int GenericVector< T >::choose_nth_item ( int target_index )

inline

Definition at line 298 of file genericvector.h.

                                         {
     // Make sure target_index is legal.
     if (target_index < 0)
       target_index = 0;                   // ensure legal
     else if (target_index >= size_used_)
       target_index = size_used_ - 1;
     unsigned int seed = 1;
     return choose_nth_item(target_index, 0, size_used_, &seed);
   }

template<typename T >

int GenericVector< T >::choose_nth_item	(	int	target_index,
		int	start,
		int	end,
		unsigned int *	seed
	)

protected

Definition at line 1016 of file genericvector.h.

                                                           {
   // Number of elements to process.
   int num_elements = end - start;
   // Trivial cases.
   if (num_elements <= 1)
     return start;
   if (num_elements == 2) {
     if (data_[start] < data_[start + 1]) {
       return target_index > start ? start + 1 : start;
     } else {
       return target_index > start ? start : start + 1;
     }
   }
   // Place the pivot at start.
   #ifndef rand_r  // _MSC_VER, ANDROID
   srand(*seed);
   #define rand_r(seed) rand()
   #endif  // _MSC_VER
   int pivot = rand_r(seed) % num_elements + start;
   swap(pivot, start);
   // The invariant condition here is that items [start, next_lesser) are less
   // than the pivot (which is at index next_lesser) and items
   // [prev_greater, end) are greater than the pivot, with items
   // [next_lesser, prev_greater) being equal to the pivot.
   int next_lesser = start;
   int prev_greater = end;
   for (int next_sample = start + 1; next_sample < prev_greater;) {
     if (data_[next_sample] < data_[next_lesser]) {
       swap(next_lesser++, next_sample++);
     } else if (data_[next_sample] == data_[next_lesser]) {
       ++next_sample;
     } else {
       swap(--prev_greater, next_sample);
     }
   }
   // Now the invariant is set up, we recurse on just the section that contains
   // the desired index.
   if (target_index < next_lesser)
     return choose_nth_item(target_index, start, next_lesser, seed);
   else if (target_index < prev_greater)
     return next_lesser;          // In equal bracket.
   else
     return choose_nth_item(target_index, prev_greater, end, seed);
 }

template<typename T >

void GenericVector< T >::clear ( )

Definition at line 806 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 271 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 254 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 731 of file genericvector.h.

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

template<typename T >

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

Definition at line 714 of file genericvector.h.

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

template<typename T >

void GenericVector< T >::delete_data_pointers ( )

Definition at line 827 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
	)

Definition at line 902 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 >::DeSerialize	(	bool	swap,
		tesseract::TFile *	fp
	)

Definition at line 916 of file genericvector.h.

                                                                 {
   inT32 reserved;
   if (fp->FRead(&reserved, sizeof(reserved), 1) != 1) return false;
   if (swap) Reverse32(&reserved);
   reserve(reserved);
   size_used_ = reserved;
   if (fp->FRead(data_, sizeof(T), size_used_) != 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 956 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 >

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

Definition at line 968 of file genericvector.h.

                                                                        {
   uinT32 reserved;
   if (fp->FRead(&reserved, sizeof(reserved), 1) != 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 287 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 635 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 195 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 84 of file genericvector.h.

                      {
     return size_used_ == 0;
   }

template<typename T >

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

Definition at line 656 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 720 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 606 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 646 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 690 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 79 of file genericvector.h.

                      {
     return size_used_;
   }

template<typename T>

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

Definition at line 983 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 772 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 767 of file genericvector.h.

                                      {
   push_back(t);
 }

template<typename T >

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

Definition at line 781 of file genericvector.h.

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

template<typename T >

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

Definition at line 662 of file genericvector.h.

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

template<typename T >

T GenericVector< T >::pop_back ( )

Definition at line 674 of file genericvector.h.

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

template<typename T>

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

Definition at line 737 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 747 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 756 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 855 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 )

Definition at line 704 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 623 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>

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

inline

Definition at line 66 of file genericvector.h.

                                 {
     reserve(size);
     size_used_ = size;
   }

template<typename T>

void GenericVector< T >::reverse ( )

inline

Definition at line 203 of file genericvector.h.

                  {
     for (int i = 0; i < size_used_ / 2; ++i)
       Swap(&data_[i], &data_[size_used_ - 1 - i]);
   }

template<typename T >

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

Definition at line 885 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 >::Serialize ( tesseract::TFile * fp ) const

Definition at line 891 of file genericvector.h.

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

template<typename T >

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

Definition at line 934 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 >

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

Definition at line 942 of file genericvector.h.

                                                                 {
   if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 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 681 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 792 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 799 of file genericvector.h.

                                                          {
   compare_cb_ = cb;
 }

template<typename T>

int GenericVector< T >::size ( ) const

inline

Definition at line 72 of file genericvector.h.

                    {
     return size_used_;
   }

template<typename T>

int GenericVector< T >::size_reserved ( ) const

inline

Definition at line 75 of file genericvector.h.

                             {
     return size_reserved_;
   }

template<typename T >

void GenericVector< T >::sort ( )

Definition at line 998 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 219 of file genericvector.h.

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

template<typename T>

void GenericVector< T >::swap	(	int	index1,
		int	index2
	)

inline

Definition at line 309 of file genericvector.h.

                                     {
     if (index1 != index2) {
       T tmp = data_[index1];
       data_[index1] = data_[index2];
       data_[index2] = tmp;
     }
   }

template<typename T>

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

inline

Definition at line 130 of file genericvector.h.

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

template<typename T>

bool GenericVector< T >::WithinBounds	(	const T &	rangemin,
		const T &	rangemax
	)		const

inline

Definition at line 318 of file genericvector.h.

                                                                 {
     for (int i = 0; i < size_used_; ++i) {
       if (data_[i] < rangemin || rangemax < data_[i])
         return false;
     }
     return true;
   }

template<typename T>

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

Definition at line 836 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 340 of file genericvector.h.

template<typename T>

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

mutableprotected

Definition at line 342 of file genericvector.h.

template<typename T>

T* GenericVector< T >::data_

protected

Definition at line 339 of file genericvector.h.

template<typename T>

const int GenericVector< T >::kDefaultVectorSize = 4

staticprotected

Definition at line 336 of file genericvector.h.

template<typename T>

inT32 GenericVector< T >::size_reserved_

protected

Definition at line 338 of file genericvector.h.

template<typename T>

inT32 GenericVector< T >::size_used_

protected

Definition at line 337 of file genericvector.h.

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

api/baseapi.h
ccutil/genericvector.h

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

template<typename T> singleton GenericVector< T >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T>
singleton GenericVector< T >