#include <baseapi.h>

Inheritance diagram for GenericVector< T >:

Public Member Functions
	GenericVector ()

	GenericVector (int size, const 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, const T &t)

void	resize_no_init (int size)

int	size () const

size_t	unsigned_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 (const T &object) const

bool	contains (const T &object) const

T	contains_index (int index) const

int	push_back (T object)

void	operator+= (const T &t)

int	push_back_new (const T &object)

int	push_front (const T &object)

void	set (const T &t, int index)

void	insert (const 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 (tesseract::TFile f, TessResultCallback2< bool, tesseract::TFile , T * > *cb)

bool	Serialize (FILE *fp) const

bool	Serialize (tesseract::TFile *fp) const

bool	DeSerialize (bool swap, FILE *fp)

bool	DeSerialize (tesseract::TFile *fp)

bool	SerializeClasses (FILE *fp) const

bool	SerializeClasses (tesseract::TFile *fp) const

bool	DeSerializeClasses (bool swap, FILE *fp)

bool	DeSerializeClasses (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 bool	SkipDeSerialize (tesseract::TFile *fp)

static bool	SkipDeSerializeClasses (tesseract::TFile *fp)

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_t	size_used_ {}

int32_t	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 37 of file baseapi.h.

Constructor & Destructor Documentation

template<typename T>

GenericVector< T >::GenericVector ( )

inline

Definition at line 38 of file genericvector.h.

                   {
     init(kDefaultVectorSize);
   }

template<typename T>

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

inline

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

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

template<typename T >

GenericVector< T >::~GenericVector ( )

Definition at line 719 of file genericvector.h.

                                  {
   clear();
 }

Member Function Documentation

template<typename T >

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

Definition at line 775 of file genericvector.h.

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

template<typename T>

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

inline

Definition at line 256 of file genericvector.h.

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

template<typename T>

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

inline

Definition at line 243 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 320 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 1173 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;
     }
     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);
   }
   if (target_index < prev_greater) {
     return next_lesser;  // In equal bracket.
   }
   return choose_nth_item(target_index, prev_greater, end, seed);
 }

template<typename T >

void GenericVector< T >::clear ( )

Definition at line 904 of file genericvector.h.

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

template<typename T>

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

inline

Definition at line 291 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 272 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 ( const T & object ) const

Definition at line 840 of file genericvector.h.

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

template<typename T >

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

Definition at line 822 of file genericvector.h.

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

template<typename T >

void GenericVector< T >::delete_data_pointers ( )

Definition at line 921 of file genericvector.h.

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

template<typename T >

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

Definition at line 1007 of file genericvector.h.

                                                       {
   uint32_t reserved;
   if (fread(&reserved, sizeof(reserved), 1, fp) != 1) {
     return false;
   }
   if (swap) {
     Reverse32(&reserved);
   }
   // Arbitrarily limit the number of elements to protect against bad data.
   assert(reserved <= UINT16_MAX);
   if (reserved > UINT16_MAX) {
     return false;
   }
   reserve(reserved);
   size_used_ = reserved;
   if (fread(data_, sizeof(T), size_used_, fp) != unsigned_size()) {
     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 ( tesseract::TFile * fp )

Definition at line 1033 of file genericvector.h.

                                                      {
   uint32_t reserved;
   if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
     return false;
   }
   // Arbitrarily limit the number of elements to protect against bad data.
   const uint32_t limit = 50000000;
   assert(reserved <= limit);
   if (reserved > limit) {
     return false;
   }
   reserve(reserved);
   size_used_ = reserved;
   return fp->FReadEndian(data_, sizeof(T), size_used_) == size_used_;
 }

template<typename T >

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

Definition at line 1091 of file genericvector.h.

                                                              {
   int32_t 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 ( tesseract::TFile * fp )

Definition at line 1109 of file genericvector.h.

                                                             {
   int32_t reserved;
   if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
     return false;
   }
   T empty;
   init_to_size(reserved, empty);
   for (int i = 0; i < reserved; ++i) {
     if (!data_[i].DeSerialize(fp)) {
       return false;
     }
   }
   return true;
 }

template<typename T>

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

inline

Definition at line 308 of file genericvector.h.

                                                      {
     T result = static_cast<T>(0);
     for (int i = std::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 743 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 211 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 89 of file genericvector.h.

                      {
     return size_used_ == 0;
   }

template<typename T >

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

Definition at line 763 of file genericvector.h.

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

template<typename T>

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

Definition at line 828 of file genericvector.h.

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

template<typename T >

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

protected

Definition at line 702 of file genericvector.h.

                                     {
   size_used_ = 0;
   if (size <= 0) {
     data_ = nullptr;
     size_reserved_ = 0;
   } else {
     if (size < kDefaultVectorSize) {
       size = kDefaultVectorSize;
     }
     data_ = new T[size];
     size_reserved_ = size;
   }
   clear_cb_ = nullptr;
   compare_cb_ = nullptr;
 }

template<typename T>

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

Definition at line 753 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	(	const T &	t,
		int	index
	)

Definition at line 797 of file genericvector.h.

                                                    {
   assert(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 84 of file genericvector.h.

                      {
     return size_used_;
   }

template<typename T>

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

Definition at line 1140 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_ = nullptr;
   from->clear_cb_ = nullptr;
   from->compare_cb_ = nullptr;
   from->size_used_ = 0;
   from->size_reserved_ = 0;
 }

template<typename T >

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

Definition at line 885 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+= ( const T & t )

Definition at line 880 of file genericvector.h.

                                             {
   push_back(t);
 }

template<typename T >

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

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

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

template<typename T >

T GenericVector< T >::pop_back ( )

Definition at line 781 of file genericvector.h.

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

template<typename T>

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

Definition at line 846 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 ( const T & object )

Definition at line 857 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 ( const T & object )

Definition at line 867 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	(	tesseract::TFile *	f,
		TessResultCallback2< bool, tesseract::TFile , T > *	cb
	)

Definition at line 953 of file genericvector.h.

                                                                            {
   int32_t reserved;
   if (f->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
     return false;
   }
   reserve(reserved);
   if (f->FReadEndian(&size_used_, sizeof(size_used_), 1) != 1) {
     return false;
   }
   if (cb != nullptr) {
     for (int i = 0; i < size_used_; ++i) {
       if (!cb->Run(f, data_ + i)) {
         delete cb;
         return false;
       }
     }
     delete cb;
   } else {
     if (f->FReadEndian(data_, sizeof(T), size_used_) != size_used_) {
       return false;
     }
   }
   return true;
 }

template<typename T >

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

Definition at line 812 of file genericvector.h.

                                        {
   assert(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 726 of file genericvector.h.

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

template<typename T>

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

inline

Definition at line 64 of file genericvector.h.

                                 {
     reserve(size);
     size_used_ = size;
   }

template<typename T>

void GenericVector< T >::reverse ( )

inline

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

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

template<typename T >

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

Definition at line 992 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 1061 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 1073 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	(	const T &	t,
		int	index
	)

Definition at line 788 of file genericvector.h.

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

template<typename T>

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

inline

Definition at line 143 of file genericvector.h.

                                                 {
     clear_cb_ = cb;
   }

template<typename T>

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

inline

Definition at line 149 of file genericvector.h.

                                                                                {
     compare_cb_ = cb;
   }

template<typename T>

int GenericVector< T >::size ( ) const

inline

Definition at line 70 of file genericvector.h.

                    {
     return size_used_;
   }

template<typename T>

int GenericVector< T >::size_reserved ( ) const

inline

Definition at line 80 of file genericvector.h.

                             {
     return size_reserved_;
   }

template<typename T >

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

static

Definition at line 1049 of file genericvector.h.

                                                          {
   uint32_t reserved;
   if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
     return false;
   }
   return (uint32_t)fp->FRead(nullptr, sizeof(T), reserved) == reserved;
 }

template<typename T >

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

static

Definition at line 1124 of file genericvector.h.

                                                                 {
   int32_t reserved;
   if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
     return false;
   }
   for (int i = 0; i < reserved; ++i) {
     if (!T::SkipDeSerialize(fp)) {
       return false;
     }
   }
   return true;
 }

template<typename T >

void GenericVector< T >::sort ( )

Definition at line 1155 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 236 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 332 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 135 of file genericvector.h.

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

template<typename T>

size_t GenericVector< T >::unsigned_size ( ) const

inline

Definition at line 74 of file genericvector.h.

                                {
     static_assert(sizeof(size_used_) <= sizeof(size_t),
                   "Wow! sizeof(size_t) < sizeof(int32_t)!!");
     assert(0 <= size_used_);
     return static_cast<size_t>(size_used_);
   }

template<typename T>

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

inline

Definition at line 341 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 928 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 != nullptr) {
     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) != unsigned_size()) {
       return false;
     }
   }
   return true;
 }

Member Data Documentation

template<typename T>

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

protected

Definition at line 364 of file genericvector.h.

template<typename T>

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

mutableprotected

Definition at line 366 of file genericvector.h.

template<typename T>

T* GenericVector< T >::data_

protected

Definition at line 363 of file genericvector.h.

template<typename T>

const int GenericVector< T >::kDefaultVectorSize = 4

staticprotected

Definition at line 360 of file genericvector.h.

template<typename T>

int32_t GenericVector< T >::size_reserved_ {}

protected

Definition at line 362 of file genericvector.h.

template<typename T>

int32_t GenericVector< T >::size_used_ {}

protected

Definition at line 361 of file genericvector.h.

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

src/api/baseapi.h
src/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 >