tesseract  3.05.01
GenericVector< T > Class Template Reference

#include <baseapi.h>

Inheritance diagram for GenericVector< T >:
GenericVectorEqEq< T > tesseract::PointerVector< tesseract::BaselineBlock > tesseract::PointerVector< tesseract::BaselineRow > tesseract::PointerVector< tesseract::DocumentData > tesseract::PointerVector< tesseract::ImageData > tesseract::PointerVector< tesseract::LanguageModelState > tesseract::PointerVector< tesseract::Shape > tesseract::PointerVector< tesseract::TrainingSample > tesseract::PointerVector< WERD_RES >

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
 
pop_back ()
 
int get_index (T object) const
 
bool contains (T object) const
 
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)
 
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 (bool swap, tesseract::TFile *fp)
 
static bool SkipDeSerializeClasses (bool swap, 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 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 41 of file baseapi.h.

Constructor & Destructor Documentation

◆ GenericVector() [1/3]

template<typename T>
GenericVector< T >::GenericVector ( )
inline

Definition at line 40 of file genericvector.h.

40  : size_used_(0), size_reserved_(0), data_(NULL),
41  clear_cb_(NULL), compare_cb_(NULL) {}
TessResultCallback2< bool, T const &, T const & > * compare_cb_
TessCallback1< T > * clear_cb_
inT32 size_reserved_

◆ GenericVector() [2/3]

template<typename T>
GenericVector< T >::GenericVector ( int  size,
init_val 
)
inline

Definition at line 43 of file genericvector.h.

43  {
44  init(size);
45  init_to_size(size, init_val);
46  }
void init(int size)
int size() const
Definition: genericvector.h:72
void init_to_size(int size, T t)

◆ GenericVector() [3/3]

template<typename T>
GenericVector< T >::GenericVector ( const GenericVector< T > &  other)
inline

Definition at line 49 of file genericvector.h.

49  {
50  this->init(other.size());
51  this->operator+=(other);
52  }
void init(int size)
GenericVector< T > & operator+=(const GenericVector &other)
int size() const
Definition: genericvector.h:72

◆ ~GenericVector()

template<typename T >
GenericVector< T >::~GenericVector ( )

Definition at line 642 of file genericvector.h.

642  {
643  clear();
644 }

Member Function Documentation

◆ back()

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

Definition at line 695 of file genericvector.h.

695  {
696  ASSERT_HOST(size_used_ > 0);
697  return data_[size_used_ - 1];
698 }
#define ASSERT_HOST(x)
Definition: errcode.h:84

◆ binary_search()

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

Definition at line 242 of file genericvector.h.

242  {
243  int bottom = 0;
244  int top = size_used_;
245  while (top - bottom > 1) {
246  int middle = (bottom + top) / 2;
247  if (data_[middle] > target)
248  top = middle;
249  else
250  bottom = middle;
251  }
252  return bottom;
253  }

◆ bool_binary_search()

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

Definition at line 230 of file genericvector.h.

230  {
231  int index = binary_search(target);
232  if (index >= size_used_)
233  return false;
234  return data_[index] == target;
235  }
int binary_search(const T &target) const

◆ choose_nth_item() [1/2]

template<typename T>
int GenericVector< T >::choose_nth_item ( int  target_index)
inline

Definition at line 301 of file genericvector.h.

301  {
302  // Make sure target_index is legal.
303  if (target_index < 0)
304  target_index = 0; // ensure legal
305  else if (target_index >= size_used_)
306  target_index = size_used_ - 1;
307  unsigned int seed = 1;
308  return choose_nth_item(target_index, 0, size_used_, &seed);
309  }
int choose_nth_item(int target_index)

◆ choose_nth_item() [2/2]

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

Definition at line 1060 of file genericvector.h.

1061  {
1062  // Number of elements to process.
1063  int num_elements = end - start;
1064  // Trivial cases.
1065  if (num_elements <= 1)
1066  return start;
1067  if (num_elements == 2) {
1068  if (data_[start] < data_[start + 1]) {
1069  return target_index > start ? start + 1 : start;
1070  } else {
1071  return target_index > start ? start : start + 1;
1072  }
1073  }
1074  // Place the pivot at start.
1075  #ifndef rand_r // _MSC_VER, ANDROID
1076  srand(*seed);
1077  #define rand_r(seed) rand()
1078  #endif // _MSC_VER
1079  int pivot = rand_r(seed) % num_elements + start;
1080  swap(pivot, start);
1081  // The invariant condition here is that items [start, next_lesser) are less
1082  // than the pivot (which is at index next_lesser) and items
1083  // [prev_greater, end) are greater than the pivot, with items
1084  // [next_lesser, prev_greater) being equal to the pivot.
1085  int next_lesser = start;
1086  int prev_greater = end;
1087  for (int next_sample = start + 1; next_sample < prev_greater;) {
1088  if (data_[next_sample] < data_[next_lesser]) {
1089  swap(next_lesser++, next_sample++);
1090  } else if (data_[next_sample] == data_[next_lesser]) {
1091  ++next_sample;
1092  } else {
1093  swap(--prev_greater, next_sample);
1094  }
1095  }
1096  // Now the invariant is set up, we recurse on just the section that contains
1097  // the desired index.
1098  if (target_index < next_lesser)
1099  return choose_nth_item(target_index, start, next_lesser, seed);
1100  else if (target_index < prev_greater)
1101  return next_lesser; // In equal bracket.
1102  else
1103  return choose_nth_item(target_index, prev_greater, end, seed);
1104 }
void swap(int index1, int index2)
#define rand_r(seed)
int choose_nth_item(int target_index)

◆ clear()

template<typename T >
void GenericVector< T >::clear ( )

Definition at line 833 of file genericvector.h.

833  {
834  if (size_reserved_ > 0) {
835  if (clear_cb_ != NULL)
836  for (int i = 0; i < size_used_; ++i)
837  clear_cb_->Run(data_[i]);
838  delete[] data_;
839  data_ = NULL;
840  size_used_ = 0;
841  size_reserved_ = 0;
842  }
843  if (clear_cb_ != NULL) {
844  delete clear_cb_;
845  clear_cb_ = NULL;
846  }
847  if (compare_cb_ != NULL) {
848  delete compare_cb_;
849  compare_cb_ = NULL;
850  }
851 }
TessResultCallback2< bool, T const &, T const & > * compare_cb_
virtual void Run(A1)=0
TessCallback1< T > * clear_cb_
inT32 size_reserved_

◆ compact()

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

Definition at line 274 of file genericvector.h.

274  {
275  int new_size = 0;
276  int old_index = 0;
277  // Until the callback returns true, the elements stay the same.
278  while (old_index < size_used_ && !delete_cb->Run(old_index++))
279  ++new_size;
280  // Now just copy anything else that gets false from delete_cb.
281  for (; old_index < size_used_; ++old_index) {
282  if (!delete_cb->Run(old_index)) {
283  data_[new_size++] = data_[old_index];
284  }
285  }
286  size_used_ = new_size;
287  delete delete_cb;
288  }
virtual R Run(A1)=0

◆ compact_sorted()

template<typename T>
void GenericVector< T >::compact_sorted ( )
inline

Definition at line 257 of file genericvector.h.

257  {
258  if (size_used_ == 0)
259  return;
260 
261  // First element is in no matter what, hence the i = 1.
262  int last_write = 0;
263  for (int i = 1; i < size_used_; ++i) {
264  // Finds next unique item and writes it.
265  if (data_[last_write] != data_[i])
266  data_[++last_write] = data_[i];
267  }
268  // last_write is the index of a valid data cell, so add 1.
269  size_used_ = last_write + 1;
270  }

◆ contains()

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

Definition at line 758 of file genericvector.h.

758  {
759  return get_index(object) != -1;
760 }
int get_index(T object) const

◆ contains_index()

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

Definition at line 741 of file genericvector.h.

741  {
742  return index >= 0 && index < size_used_;
743 }

◆ delete_data_pointers()

template<typename T >
void GenericVector< T >::delete_data_pointers ( )

Definition at line 854 of file genericvector.h.

854  {
855  for (int i = 0; i < size_used_; ++i)
856  if (data_[i]) {
857  delete data_[i];
858  }
859 }

◆ DeSerialize() [1/2]

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

Definition at line 929 of file genericvector.h.

929  {
930  inT32 reserved;
931  if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
932  if (swap) Reverse32(&reserved);
933  reserve(reserved);
934  size_used_ = reserved;
935  if (fread(data_, sizeof(T), size_used_, fp) != size_used_) return false;
936  if (swap) {
937  for (int i = 0; i < size_used_; ++i)
938  ReverseN(&data_[i], sizeof(data_[i]));
939  }
940  return true;
941 }
void Reverse32(void *ptr)
Definition: helpers.h:193
void swap(int index1, int index2)
int inT32
Definition: host.h:102
void reserve(int size)
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:177

◆ DeSerialize() [2/2]

template<typename T >
bool GenericVector< T >::DeSerialize ( bool  swap,
tesseract::TFile fp 
)

Definition at line 943 of file genericvector.h.

943  {
944  inT32 reserved;
945  if (fp->FRead(&reserved, sizeof(reserved), 1) != 1) return false;
946  if (swap) Reverse32(&reserved);
947  reserve(reserved);
948  size_used_ = reserved;
949  if (fp->FRead(data_, sizeof(T), size_used_) != size_used_) return false;
950  if (swap) {
951  for (int i = 0; i < size_used_; ++i)
952  ReverseN(&data_[i], sizeof(data_[i]));
953  }
954  return true;
955 }
void Reverse32(void *ptr)
Definition: helpers.h:193
void swap(int index1, int index2)
int FRead(void *buffer, int size, int count)
Definition: serialis.cpp:91
int inT32
Definition: host.h:102
void reserve(int size)
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:177

◆ DeSerializeClasses() [1/2]

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

Definition at line 990 of file genericvector.h.

990  {
991  uinT32 reserved;
992  if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
993  if (swap) Reverse32(&reserved);
994  T empty;
995  init_to_size(reserved, empty);
996  for (int i = 0; i < reserved; ++i) {
997  if (!data_[i].DeSerialize(swap, fp)) return false;
998  }
999  return true;
1000 }
void Reverse32(void *ptr)
Definition: helpers.h:193
void swap(int index1, int index2)
unsigned int uinT32
Definition: host.h:103
bool empty() const
Definition: genericvector.h:84
void init_to_size(int size, T t)
bool DeSerialize(bool swap, FILE *fp)

◆ DeSerializeClasses() [2/2]

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

Definition at line 1002 of file genericvector.h.

1002  {
1003  uinT32 reserved;
1004  if (fp->FRead(&reserved, sizeof(reserved), 1) != 1) return false;
1005  if (swap) Reverse32(&reserved);
1006  T empty;
1007  init_to_size(reserved, empty);
1008  for (int i = 0; i < reserved; ++i) {
1009  if (!data_[i].DeSerialize(swap, fp)) return false;
1010  }
1011  return true;
1012 }
void Reverse32(void *ptr)
Definition: helpers.h:193
void swap(int index1, int index2)
int FRead(void *buffer, int size, int count)
Definition: serialis.cpp:91
unsigned int uinT32
Definition: host.h:103
bool empty() const
Definition: genericvector.h:84
void init_to_size(int size, T t)
bool DeSerialize(bool swap, FILE *fp)

◆ dot_product()

template<typename T>
T GenericVector< T >::dot_product ( const GenericVector< T > &  other) const
inline

Definition at line 290 of file genericvector.h.

290  {
291  T result = static_cast<T>(0);
292  for (int i = MIN(size_used_, other.size_used_) - 1; i >= 0; --i)
293  result += data_[i] * other.data_[i];
294  return result;
295  }
#define MIN(x, y)
Definition: ndminx.h:28

◆ double_the_size()

template<typename T >
void GenericVector< T >::double_the_size ( )

Definition at line 662 of file genericvector.h.

662  {
663  if (size_reserved_ == 0) {
665  }
666  else {
667  reserve(2 * size_reserved_);
668  }
669 }
static const int kDefaultVectorSize
void reserve(int size)
inT32 size_reserved_

◆ double_the_size_memcpy()

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

Definition at line 199 of file genericvector.h.

199  {
200  T *data_new = new T[current_size * 2];
201  memcpy(data_new, data, sizeof(T) * current_size);
202  delete[] data;
203  return data_new;
204  }

◆ empty()

template<typename T>
bool GenericVector< T >::empty ( ) const
inline

Definition at line 84 of file genericvector.h.

84  {
85  return size_used_ == 0;
86  }

◆ get()

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

Definition at line 683 of file genericvector.h.

683  {
684  ASSERT_HOST(index >= 0 && index < size_used_);
685  return data_[index];
686 }
#define ASSERT_HOST(x)
Definition: errcode.h:84

◆ get_index()

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

Definition at line 747 of file genericvector.h.

747  {
748  for (int i = 0; i < size_used_; ++i) {
749  ASSERT_HOST(compare_cb_ != NULL);
750  if (compare_cb_->Run(object, data_[i]))
751  return i;
752  }
753  return -1;
754 }
TessResultCallback2< bool, T const &, T const & > * compare_cb_
virtual R Run(A1, A2)=0
#define ASSERT_HOST(x)
Definition: errcode.h:84

◆ init()

template<typename T >
void GenericVector< T >::init ( int  size)
protected

Definition at line 632 of file genericvector.h.

632  {
633  size_used_ = 0;
634  size_reserved_ = 0;
635  data_ = 0;
636  clear_cb_ = 0;
637  compare_cb_ = 0;
638  reserve(size);
639 }
TessResultCallback2< bool, T const &, T const & > * compare_cb_
TessCallback1< T > * clear_cb_
int size() const
Definition: genericvector.h:72
void reserve(int size)
inT32 size_reserved_

◆ init_to_size()

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

Definition at line 673 of file genericvector.h.

673  {
674  reserve(size);
675  size_used_ = size;
676  for (int i = 0; i < size; ++i)
677  data_[i] = t;
678 }
int size() const
Definition: genericvector.h:72
void reserve(int size)

◆ insert()

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

Definition at line 717 of file genericvector.h.

717  {
718  ASSERT_HOST(index >= 0 && index <= size_used_);
719  if (size_reserved_ == size_used_)
720  double_the_size();
721  for (int i = size_used_; i > index; --i) {
722  data_[i] = data_[i-1];
723  }
724  data_[index] = t;
725  size_used_++;
726 }
void double_the_size()
#define ASSERT_HOST(x)
Definition: errcode.h:84
inT32 size_reserved_

◆ length()

template<typename T>
int GenericVector< T >::length ( ) const
inline

Definition at line 79 of file genericvector.h.

79  {
80  return size_used_;
81  }

◆ move()

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

Definition at line 1027 of file genericvector.h.

1027  {
1028  this->clear();
1029  this->data_ = from->data_;
1030  this->size_reserved_ = from->size_reserved_;
1031  this->size_used_ = from->size_used_;
1032  this->compare_cb_ = from->compare_cb_;
1033  this->clear_cb_ = from->clear_cb_;
1034  from->data_ = NULL;
1035  from->clear_cb_ = NULL;
1036  from->compare_cb_ = NULL;
1037  from->size_used_ = 0;
1038  from->size_reserved_ = 0;
1039 }
TessResultCallback2< bool, T const &, T const & > * compare_cb_
TessCallback1< T > * clear_cb_
inT32 size_reserved_

◆ operator+=() [1/2]

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

Definition at line 799 of file genericvector.h.

799  {
800  this->reserve(size_used_ + other.size_used_);
801  for (int i = 0; i < other.size(); ++i) {
802  this->operator+=(other.data_[i]);
803  }
804  return *this;
805 }
GenericVector< T > & operator+=(const GenericVector &other)
int size() const
Definition: genericvector.h:72
void reserve(int size)

◆ operator+=() [2/2]

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

Definition at line 794 of file genericvector.h.

794  {
795  push_back(t);
796 }
int push_back(T object)

◆ operator=()

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

Definition at line 808 of file genericvector.h.

808  {
809  if (&other != this) {
810  this->truncate(0);
811  this->operator+=(other);
812  }
813  return *this;
814 }
GenericVector< T > & operator+=(const GenericVector &other)
void truncate(int size)

◆ operator[]()

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

Definition at line 689 of file genericvector.h.

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

◆ pop_back()

template<typename T >
T GenericVector< T >::pop_back ( )

Definition at line 701 of file genericvector.h.

701  {
702  ASSERT_HOST(size_used_ > 0);
703  return data_[--size_used_];
704 }
#define ASSERT_HOST(x)
Definition: errcode.h:84

◆ push_back()

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

Definition at line 764 of file genericvector.h.

764  {
765  int index = 0;
766  if (size_used_ == size_reserved_)
767  double_the_size();
768  index = size_used_++;
769  data_[index] = object;
770  return index;
771 }
void double_the_size()
inT32 size_reserved_

◆ push_back_new()

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

Definition at line 774 of file genericvector.h.

774  {
775  int index = get_index(object);
776  if (index >= 0)
777  return index;
778  return push_back(object);
779 }
int get_index(T object) const
int push_back(T object)

◆ push_front()

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

Definition at line 783 of file genericvector.h.

783  {
784  if (size_used_ == size_reserved_)
785  double_the_size();
786  for (int i = size_used_; i > 0; --i)
787  data_[i] = data_[i-1];
788  data_[0] = object;
789  ++size_used_;
790  return 0;
791 }
void double_the_size()
inT32 size_reserved_

◆ read()

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

Definition at line 882 of file genericvector.h.

884  {
885  inT32 reserved;
886  if (fread(&reserved, sizeof(reserved), 1, f) != 1) return false;
887  if (swap) Reverse32(&reserved);
888  reserve(reserved);
889  if (fread(&size_used_, sizeof(size_used_), 1, f) != 1) return false;
890  if (swap) Reverse32(&size_used_);
891  if (cb != NULL) {
892  for (int i = 0; i < size_used_; ++i) {
893  if (!cb->Run(f, data_ + i, swap)) {
894  delete cb;
895  return false;
896  }
897  }
898  delete cb;
899  } else {
900  if (fread(data_, sizeof(T), size_used_, f) != size_used_) return false;
901  if (swap) {
902  for (int i = 0; i < size_used_; ++i)
903  ReverseN(&data_[i], sizeof(T));
904  }
905  }
906  return true;
907 }
void Reverse32(void *ptr)
Definition: helpers.h:193
void swap(int index1, int index2)
virtual R Run(A1, A2, A3)=0
int inT32
Definition: host.h:102
void reserve(int size)
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:177

◆ remove()

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

Definition at line 731 of file genericvector.h.

731  {
732  ASSERT_HOST(index >= 0 && index < size_used_);
733  for (int i = index; i < size_used_ - 1; ++i) {
734  data_[i] = data_[i+1];
735  }
736  size_used_--;
737 }
#define ASSERT_HOST(x)
Definition: errcode.h:84

◆ reserve()

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

Definition at line 649 of file genericvector.h.

649  {
650  if (size_reserved_ >= size || size <= 0)
651  return;
653  T* new_array = new T[size];
654  for (int i = 0; i < size_used_; ++i)
655  new_array[i] = data_[i];
656  delete[] data_;
657  data_ = new_array;
659 }
static const int kDefaultVectorSize
int size() const
Definition: genericvector.h:72
inT32 size_reserved_

◆ resize_no_init()

template<typename T>
void GenericVector< T >::resize_no_init ( int  size)
inline

Definition at line 66 of file genericvector.h.

66  {
67  reserve(size);
68  size_used_ = size;
69  }
int size() const
Definition: genericvector.h:72
void reserve(int size)

◆ reverse()

template<typename T>
void GenericVector< T >::reverse ( )
inline

Definition at line 207 of file genericvector.h.

207  {
208  for (int i = 0; i < size_used_ / 2; ++i)
209  Swap(&data_[i], &data_[size_used_ - 1 - i]);
210  }
void Swap(T *p1, T *p2)
Definition: helpers.h:90

◆ Serialize() [1/2]

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

Definition at line 912 of file genericvector.h.

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

◆ Serialize() [2/2]

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

Definition at line 918 of file genericvector.h.

918  {
919  if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) return false;
920  if (fp->FWrite(data_, sizeof(*data_), size_used_) != size_used_) return false;
921  return true;
922 }
int FWrite(const void *buffer, int size, int count)
Definition: serialis.cpp:131

◆ SerializeClasses() [1/2]

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

Definition at line 968 of file genericvector.h.

968  {
969  if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) return false;
970  for (int i = 0; i < size_used_; ++i) {
971  if (!data_[i].Serialize(fp)) return false;
972  }
973  return true;
974 }
bool Serialize(FILE *fp) const

◆ SerializeClasses() [2/2]

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

Definition at line 976 of file genericvector.h.

976  {
977  if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) return false;
978  for (int i = 0; i < size_used_; ++i) {
979  if (!data_[i].Serialize(fp)) return false;
980  }
981  return true;
982 }
int FWrite(const void *buffer, int size, int count)
Definition: serialis.cpp:131
bool Serialize(FILE *fp) const

◆ set()

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

Definition at line 708 of file genericvector.h.

708  {
709  ASSERT_HOST(index >= 0 && index < size_used_);
710  data_[index] = t;
711 }
#define ASSERT_HOST(x)
Definition: errcode.h:84

◆ set_clear_callback()

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

Definition at line 819 of file genericvector.h.

819  {
820  clear_cb_ = cb;
821 }
TessCallback1< T > * clear_cb_

◆ set_compare_callback()

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

Definition at line 826 of file genericvector.h.

827  {
828  compare_cb_ = cb;
829 }
TessResultCallback2< bool, T const &, T const & > * compare_cb_

◆ size()

template<typename T>
int GenericVector< T >::size ( ) const
inline

Definition at line 72 of file genericvector.h.

72  {
73  return size_used_;
74  }

◆ size_reserved()

template<typename T>
int GenericVector< T >::size_reserved ( ) const
inline

Definition at line 75 of file genericvector.h.

75  {
76  return size_reserved_;
77  }
inT32 size_reserved_

◆ SkipDeSerialize()

template<typename T >
bool GenericVector< T >::SkipDeSerialize ( bool  swap,
tesseract::TFile fp 
)
static

Definition at line 957 of file genericvector.h.

957  {
958  inT32 reserved;
959  if (fp->FRead(&reserved, sizeof(reserved), 1) != 1) return false;
960  if (swap) Reverse32(&reserved);
961  return fp->FRead(NULL, sizeof(T), reserved) == reserved;
962 }
void Reverse32(void *ptr)
Definition: helpers.h:193
void swap(int index1, int index2)
int FRead(void *buffer, int size, int count)
Definition: serialis.cpp:91
int inT32
Definition: host.h:102

◆ SkipDeSerializeClasses()

template<typename T >
bool GenericVector< T >::SkipDeSerializeClasses ( bool  swap,
tesseract::TFile fp 
)
static

Definition at line 1014 of file genericvector.h.

1014  {
1015  uinT32 reserved;
1016  if (fp->FRead(&reserved, sizeof(reserved), 1) != 1) return false;
1017  if (swap) Reverse32(&reserved);
1018  for (int i = 0; i < reserved; ++i) {
1019  if (!T::SkipDeSerialize(swap, fp)) return false;
1020  }
1021  return true;
1022 }
void Reverse32(void *ptr)
Definition: helpers.h:193
void swap(int index1, int index2)
int FRead(void *buffer, int size, int count)
Definition: serialis.cpp:91
unsigned int uinT32
Definition: host.h:103

◆ sort() [1/2]

template<typename T >
void GenericVector< T >::sort ( )

Definition at line 1042 of file genericvector.h.

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

◆ sort() [2/2]

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

Definition at line 223 of file genericvector.h.

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

◆ swap()

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

Definition at line 312 of file genericvector.h.

312  {
313  if (index1 != index2) {
314  T tmp = data_[index1];
315  data_[index1] = data_[index2];
316  data_[index2] = tmp;
317  }
318  }

◆ truncate()

template<typename T>
void GenericVector< T >::truncate ( int  size)
inline

Definition at line 130 of file genericvector.h.

130  {
131  if (size < size_used_)
132  size_used_ = size;
133  }
int size() const
Definition: genericvector.h:72

◆ WithinBounds()

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

Definition at line 321 of file genericvector.h.

321  {
322  for (int i = 0; i < size_used_; ++i) {
323  if (data_[i] < rangemin || rangemax < data_[i])
324  return false;
325  }
326  return true;
327  }

◆ write()

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

Definition at line 863 of file genericvector.h.

864  {
865  if (fwrite(&size_reserved_, sizeof(size_reserved_), 1, f) != 1) return false;
866  if (fwrite(&size_used_, sizeof(size_used_), 1, f) != 1) return false;
867  if (cb != NULL) {
868  for (int i = 0; i < size_used_; ++i) {
869  if (!cb->Run(f, data_[i])) {
870  delete cb;
871  return false;
872  }
873  }
874  delete cb;
875  } else {
876  if (fwrite(data_, sizeof(T), size_used_, f) != size_used_) return false;
877  }
878  return true;
879 }
virtual R Run(A1, A2)=0
inT32 size_reserved_

Member Data Documentation

◆ clear_cb_

template<typename T>
TessCallback1<T>* GenericVector< T >::clear_cb_
protected

Definition at line 343 of file genericvector.h.

◆ compare_cb_

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

Definition at line 345 of file genericvector.h.

◆ data_

template<typename T>
T* GenericVector< T >::data_
protected

Definition at line 342 of file genericvector.h.

◆ kDefaultVectorSize

template<typename T>
const int GenericVector< T >::kDefaultVectorSize = 4
staticprotected

Definition at line 339 of file genericvector.h.

◆ size_reserved_

template<typename T>
inT32 GenericVector< T >::size_reserved_
protected

Definition at line 341 of file genericvector.h.

◆ size_used_

template<typename T>
inT32 GenericVector< T >::size_used_
protected

Definition at line 340 of file genericvector.h.


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