tesseract  4.1.1
GenericVector< T > Class Template Reference

#include <genericvector.h>

Inheritance diagram for GenericVector< T >:
GenericVectorEqEq< tesseract::LineHypothesis > tesseract::PointerVector< tesseract::TrainingSample > tesseract::PointerVector< tesseract::BaselineBlock > tesseract::PointerVector< tesseract::DocumentData > tesseract::PointerVector< tesseract::LanguageModelState > tesseract::PointerVector< tesseract::Shape > tesseract::PointerVector< tesseract::Network > tesseract::PointerVector< tesseract::ImageData > tesseract::PointerVector< WERD_RES > tesseract::PointerVector< tesseract::BaselineRow > tesseract::PointerVector< RecodeBeam > GenericVectorEqEq< 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
 
pop_back ()
 
int get_index (const T &object) const
 
bool contains (const T &object) const
 
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)
 
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 38 of file genericvector.h.

Constructor & Destructor Documentation

◆ GenericVector() [1/3]

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

Definition at line 40 of file genericvector.h.

40  {
42  }
static const int kDefaultVectorSize
void init(int size)

◆ GenericVector() [2/3]

template<typename T >
GenericVector< T >::GenericVector ( int  size,
const T &  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_to_size(int size, const T &t)
int size() const
Definition: genericvector.h:72

◆ 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  }
GenericVector< T > & operator+=(const GenericVector &other)

◆ ~GenericVector()

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

Definition at line 710 of file genericvector.h.

710  {
711  clear();
712 }

Member Function Documentation

◆ back()

template<typename T >
T & GenericVector< T >::back

Definition at line 766 of file genericvector.h.

766  {
767  assert(size_used_ > 0);
768  return data_[size_used_ - 1];
769 }
int32_t size_used_

◆ binary_search()

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

Definition at line 258 of file genericvector.h.

258  {
259  int bottom = 0;
260  int top = size_used_;
261  while (top - bottom > 1) {
262  int middle = (bottom + top) / 2;
263  if (data_[middle] > target) {
264  top = middle;
265  } else {
266  bottom = middle;
267  }
268  }
269  return bottom;
270  }

◆ bool_binary_search()

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

Definition at line 245 of file genericvector.h.

245  {
246  int index = binary_search(target);
247  if (index >= size_used_) {
248  return false;
249  }
250  return data_[index] == target;
251  }
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 322 of file genericvector.h.

322  {
323  // Make sure target_index is legal.
324  if (target_index < 0) {
325  target_index = 0; // ensure legal
326  } else if (target_index >= size_used_) {
327  target_index = size_used_ - 1;
328  }
329  unsigned int seed = 1;
330  return choose_nth_item(target_index, 0, size_used_, &seed);
331  }
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 1164 of file genericvector.h.

1165  {
1166  // Number of elements to process.
1167  int num_elements = end - start;
1168  // Trivial cases.
1169  if (num_elements <= 1) {
1170  return start;
1171  }
1172  if (num_elements == 2) {
1173  if (data_[start] < data_[start + 1]) {
1174  return target_index > start ? start + 1 : start;
1175  }
1176  return target_index > start ? start : start + 1;
1177  }
1178 // Place the pivot at start.
1179 #ifndef rand_r // _MSC_VER, ANDROID
1180  srand(*seed);
1181 # define rand_r(seed) rand()
1182 #endif // _MSC_VER
1183  int pivot = rand_r(seed) % num_elements + start;
1184  swap(pivot, start);
1185  // The invariant condition here is that items [start, next_lesser) are less
1186  // than the pivot (which is at index next_lesser) and items
1187  // [prev_greater, end) are greater than the pivot, with items
1188  // [next_lesser, prev_greater) being equal to the pivot.
1189  int next_lesser = start;
1190  int prev_greater = end;
1191  for (int next_sample = start + 1; next_sample < prev_greater;) {
1192  if (data_[next_sample] < data_[next_lesser]) {
1193  swap(next_lesser++, next_sample++);
1194  } else if (data_[next_sample] == data_[next_lesser]) {
1195  ++next_sample;
1196  } else {
1197  swap(--prev_greater, next_sample);
1198  }
1199  }
1200  // Now the invariant is set up, we recurse on just the section that contains
1201  // the desired index.
1202  if (target_index < next_lesser) {
1203  return choose_nth_item(target_index, start, next_lesser, seed);
1204  }
1205  if (target_index < prev_greater) {
1206  return next_lesser; // In equal bracket.
1207  }
1208  return choose_nth_item(target_index, prev_greater, end, seed);
1209 }
#define rand_r(seed)
void swap(int index1, int index2)

◆ clear()

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

Definition at line 895 of file genericvector.h.

895  {
896  if (size_reserved_ > 0 && clear_cb_ != nullptr) {
897  for (int i = 0; i < size_used_; ++i) {
898  clear_cb_->Run(data_[i]);
899  }
900  }
901  delete[] data_;
902  data_ = nullptr;
903  size_used_ = 0;
904  size_reserved_ = 0;
905  delete clear_cb_;
906  clear_cb_ = nullptr;
907  delete compare_cb_;
908  compare_cb_ = nullptr;
909 }
int32_t size_reserved_
TessCallback1< T > * clear_cb_
TessResultCallback2< bool, T const &, T const & > * compare_cb_
virtual void Run(A1)=0

◆ compact()

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

Definition at line 293 of file genericvector.h.

293  {
294  int new_size = 0;
295  int old_index = 0;
296  // Until the callback returns true, the elements stay the same.
297  while (old_index < size_used_ && !delete_cb->Run(old_index++)) {
298  ++new_size;
299  }
300  // Now just copy anything else that gets false from delete_cb.
301  for (; old_index < size_used_; ++old_index) {
302  if (!delete_cb->Run(old_index)) {
303  data_[new_size++] = data_[old_index];
304  }
305  }
306  size_used_ = new_size;
307  delete delete_cb;
308  }
virtual R Run(A1)=0

◆ compact_sorted()

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

Definition at line 274 of file genericvector.h.

274  {
275  if (size_used_ == 0) {
276  return;
277  }
278 
279  // First element is in no matter what, hence the i = 1.
280  int last_write = 0;
281  for (int i = 1; i < size_used_; ++i) {
282  // Finds next unique item and writes it.
283  if (data_[last_write] != data_[i]) {
284  data_[++last_write] = data_[i];
285  }
286  }
287  // last_write is the index of a valid data cell, so add 1.
288  size_used_ = last_write + 1;
289  }

◆ contains()

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

Definition at line 831 of file genericvector.h.

831  {
832  return get_index(object) != -1;
833 }
int get_index(const T &object) const

◆ contains_index()

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

Definition at line 813 of file genericvector.h.

813  {
814  return index >= 0 && index < size_used_;
815 }

◆ delete_data_pointers()

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

Definition at line 912 of file genericvector.h.

912  {
913  for (int i = 0; i < size_used_; ++i) {
914  delete data_[i];
915  }
916 }

◆ DeSerialize() [1/2]

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

Definition at line 998 of file genericvector.h.

998  {
999  uint32_t reserved;
1000  if (fread(&reserved, sizeof(reserved), 1, fp) != 1) {
1001  return false;
1002  }
1003  if (swap) {
1004  Reverse32(&reserved);
1005  }
1006  // Arbitrarily limit the number of elements to protect against bad data.
1007  assert(reserved <= UINT16_MAX);
1008  if (reserved > UINT16_MAX) {
1009  return false;
1010  }
1011  reserve(reserved);
1012  size_used_ = reserved;
1013  if (fread(data_, sizeof(T), size_used_, fp) != unsigned_size()) {
1014  return false;
1015  }
1016  if (swap) {
1017  for (int i = 0; i < size_used_; ++i) {
1018  ReverseN(&data_[i], sizeof(data_[i]));
1019  }
1020  }
1021  return true;
1022 }
void Reverse32(void *ptr)
Definition: helpers.h:202
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:185
size_t unsigned_size() const
Definition: genericvector.h:76
void reserve(int size)

◆ DeSerialize() [2/2]

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

Definition at line 1024 of file genericvector.h.

1024  {
1025  uint32_t reserved;
1026  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
1027  return false;
1028  }
1029  // Arbitrarily limit the number of elements to protect against bad data.
1030  const uint32_t limit = 50000000;
1031  assert(reserved <= limit);
1032  if (reserved > limit) {
1033  return false;
1034  }
1035  reserve(reserved);
1036  size_used_ = reserved;
1037  return fp->FReadEndian(data_, sizeof(T), size_used_) == size_used_;
1038 }
int FReadEndian(void *buffer, size_t size, int count)
Definition: serialis.cpp:260

◆ DeSerializeClasses() [1/2]

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

Definition at line 1082 of file genericvector.h.

1082  {
1083  int32_t reserved;
1084  if (fread(&reserved, sizeof(reserved), 1, fp) != 1) {
1085  return false;
1086  }
1087  if (swap) {
1088  Reverse32(&reserved);
1089  }
1090  T empty;
1091  init_to_size(reserved, empty);
1092  for (int i = 0; i < reserved; ++i) {
1093  if (!data_[i].DeSerialize(swap, fp)) {
1094  return false;
1095  }
1096  }
1097  return true;
1098 }
bool empty() const
Definition: genericvector.h:91
bool DeSerialize(bool swap, FILE *fp)

◆ DeSerializeClasses() [2/2]

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

Definition at line 1100 of file genericvector.h.

1100  {
1101  int32_t reserved;
1102  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
1103  return false;
1104  }
1105  T empty;
1106  init_to_size(reserved, empty);
1107  for (int i = 0; i < reserved; ++i) {
1108  if (!data_[i].DeSerialize(fp)) {
1109  return false;
1110  }
1111  }
1112  return true;
1113 }

◆ dot_product()

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

Definition at line 310 of file genericvector.h.

310  {
311  T result = static_cast<T>(0);
312  for (int i = std::min(size_used_, other.size_used_) - 1; i >= 0; --i) {
313  result += data_[i] * other.data_[i];
314  }
315  return result;
316  }

◆ double_the_size()

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

Definition at line 734 of file genericvector.h.

734  {
735  if (size_reserved_ == 0) {
737  } else {
738  reserve(2 * size_reserved_);
739  }
740 }

◆ double_the_size_memcpy()

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

Definition at line 213 of file genericvector.h.

213  {
214  T* data_new = new T[current_size * 2];
215  memcpy(data_new, data, sizeof(T) * current_size);
216  delete[] data;
217  return data_new;
218  }

◆ empty()

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

Definition at line 91 of file genericvector.h.

91  {
92  return size_used_ == 0;
93  }

◆ get()

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

Definition at line 754 of file genericvector.h.

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

◆ get_index()

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

Definition at line 819 of file genericvector.h.

819  {
820  for (int i = 0; i < size_used_; ++i) {
821  assert(compare_cb_ != nullptr);
822  if (compare_cb_->Run(object, data_[i])) {
823  return i;
824  }
825  }
826  return -1;
827 }
virtual R Run(A1, A2)=0

◆ init()

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

Definition at line 693 of file genericvector.h.

693  {
694  size_used_ = 0;
695  if (size <= 0) {
696  data_ = nullptr;
697  size_reserved_ = 0;
698  } else {
699  if (size < kDefaultVectorSize) {
701  }
702  data_ = new T[size];
704  }
705  clear_cb_ = nullptr;
706  compare_cb_ = nullptr;
707 }

◆ init_to_size()

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

Definition at line 744 of file genericvector.h.

744  {
745  reserve(size);
746  size_used_ = size;
747  for (int i = 0; i < size; ++i) {
748  data_[i] = t;
749  }
750 }

◆ insert()

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

Definition at line 788 of file genericvector.h.

788  {
789  assert(index >= 0 && index <= size_used_);
790  if (size_reserved_ == size_used_) {
791  double_the_size();
792  }
793  for (int i = size_used_; i > index; --i) {
794  data_[i] = data_[i - 1];
795  }
796  data_[index] = t;
797  size_used_++;
798 }
void double_the_size()

◆ length()

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

Definition at line 86 of file genericvector.h.

86  {
87  return size_used_;
88  }

◆ move()

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

Definition at line 1131 of file genericvector.h.

1131  {
1132  this->clear();
1133  this->data_ = from->data_;
1134  this->size_reserved_ = from->size_reserved_;
1135  this->size_used_ = from->size_used_;
1136  this->compare_cb_ = from->compare_cb_;
1137  this->clear_cb_ = from->clear_cb_;
1138  from->data_ = nullptr;
1139  from->clear_cb_ = nullptr;
1140  from->compare_cb_ = nullptr;
1141  from->size_used_ = 0;
1142  from->size_reserved_ = 0;
1143 }

◆ operator+=() [1/2]

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

Definition at line 876 of file genericvector.h.

876  {
877  this->reserve(size_used_ + other.size_used_);
878  for (int i = 0; i < other.size(); ++i) {
879  this->operator+=(other.data_[i]);
880  }
881  return *this;
882 }

◆ operator+=() [2/2]

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

Definition at line 871 of file genericvector.h.

871  {
872  push_back(t);
873 }
int push_back(T object)

◆ operator=()

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

Definition at line 885 of file genericvector.h.

885  {
886  if (&other != this) {
887  this->truncate(0);
888  this->operator+=(other);
889  }
890  return *this;
891 }
void truncate(int size)

◆ operator[]()

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

Definition at line 760 of file genericvector.h.

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

◆ pop_back()

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

Definition at line 772 of file genericvector.h.

772  {
773  assert(size_used_ > 0);
774  return data_[--size_used_];
775 }

◆ push_back()

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

Definition at line 837 of file genericvector.h.

837  {
838  int index = 0;
839  if (size_used_ == size_reserved_) {
840  double_the_size();
841  }
842  index = size_used_++;
843  data_[index] = object;
844  return index;
845 }

◆ push_back_new()

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

Definition at line 848 of file genericvector.h.

848  {
849  int index = get_index(object);
850  if (index >= 0) {
851  return index;
852  }
853  return push_back(object);
854 }

◆ push_front()

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

Definition at line 858 of file genericvector.h.

858  {
859  if (size_used_ == size_reserved_) {
860  double_the_size();
861  }
862  for (int i = size_used_; i > 0; --i) {
863  data_[i] = data_[i - 1];
864  }
865  data_[0] = object;
866  ++size_used_;
867  return 0;
868 }

◆ read()

template<typename T >
bool GenericVector< T >::read ( tesseract::TFile f,
TessResultCallback2< bool, tesseract::TFile *, T * > *  cb 
)

Definition at line 944 of file genericvector.h.

945  {
946  int32_t reserved;
947  if (f->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
948  return false;
949  }
950  reserve(reserved);
951  if (f->FReadEndian(&size_used_, sizeof(size_used_), 1) != 1) {
952  return false;
953  }
954  if (cb != nullptr) {
955  for (int i = 0; i < size_used_; ++i) {
956  if (!cb->Run(f, data_ + i)) {
957  delete cb;
958  return false;
959  }
960  }
961  delete cb;
962  } else {
963  if (f->FReadEndian(data_, sizeof(T), size_used_) != size_used_) {
964  return false;
965  }
966  }
967  return true;
968 }

◆ remove()

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

Definition at line 803 of file genericvector.h.

803  {
804  assert(index >= 0 && index < size_used_);
805  for (int i = index; i < size_used_ - 1; ++i) {
806  data_[i] = data_[i + 1];
807  }
808  size_used_--;
809 }

◆ reserve()

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

Definition at line 717 of file genericvector.h.

717  {
718  if (size_reserved_ >= size || size <= 0) {
719  return;
720  }
721  if (size < kDefaultVectorSize) {
723  }
724  T* new_array = new T[size];
725  for (int i = 0; i < size_used_; ++i) {
726  new_array[i] = data_[i];
727  }
728  delete[] data_;
729  data_ = new_array;
731 }

◆ 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  }

◆ reverse()

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

Definition at line 221 of file genericvector.h.

221  {
222  for (int i = 0; i < size_used_ / 2; ++i) {
223  Swap(&data_[i], &data_[size_used_ - 1 - i]);
224  }
225  }
void Swap(T *p1, T *p2)
Definition: helpers.h:95

◆ Serialize() [1/2]

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

Definition at line 973 of file genericvector.h.

973  {
974  if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) {
975  return false;
976  }
977  if (fwrite(data_, sizeof(*data_), size_used_, fp) != unsigned_size()) {
978  return false;
979  }
980  return true;
981 }

◆ Serialize() [2/2]

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

Definition at line 983 of file genericvector.h.

983  {
984  if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) {
985  return false;
986  }
987  if (fp->FWrite(data_, sizeof(*data_), size_used_) != size_used_) {
988  return false;
989  }
990  return true;
991 }
int FWrite(const void *buffer, size_t size, int count)
Definition: serialis.cpp:319

◆ SerializeClasses() [1/2]

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

Definition at line 1052 of file genericvector.h.

1052  {
1053  if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) {
1054  return false;
1055  }
1056  for (int i = 0; i < size_used_; ++i) {
1057  if (!data_[i].Serialize(fp)) {
1058  return false;
1059  }
1060  }
1061  return true;
1062 }
bool Serialize(FILE *fp) const

◆ SerializeClasses() [2/2]

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

Definition at line 1064 of file genericvector.h.

1064  {
1065  if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) {
1066  return false;
1067  }
1068  for (int i = 0; i < size_used_; ++i) {
1069  if (!data_[i].Serialize(fp)) {
1070  return false;
1071  }
1072  }
1073  return true;
1074 }

◆ set()

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

Definition at line 779 of file genericvector.h.

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

◆ set_clear_callback()

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

Definition at line 145 of file genericvector.h.

145  {
146  clear_cb_ = cb;
147  }

◆ set_compare_callback()

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

Definition at line 151 of file genericvector.h.

151  {
152  compare_cb_ = cb;
153  }

◆ 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 82 of file genericvector.h.

82  {
83  return size_reserved_;
84  }

◆ SkipDeSerialize()

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

Definition at line 1040 of file genericvector.h.

1040  {
1041  uint32_t reserved;
1042  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
1043  return false;
1044  }
1045  return (uint32_t)fp->FRead(nullptr, sizeof(T), reserved) == reserved;
1046 }
int FRead(void *buffer, size_t size, int count)
Definition: serialis.cpp:271

◆ SkipDeSerializeClasses()

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

Definition at line 1115 of file genericvector.h.

1115  {
1116  int32_t reserved;
1117  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
1118  return false;
1119  }
1120  for (int i = 0; i < reserved; ++i) {
1121  if (!T::SkipDeSerialize(fp)) {
1122  return false;
1123  }
1124  }
1125  return true;
1126 }

◆ sort() [1/2]

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

Definition at line 1146 of file genericvector.h.

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

◆ sort() [2/2]

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

Definition at line 238 of file genericvector.h.

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

◆ swap()

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

Definition at line 334 of file genericvector.h.

334  {
335  if (index1 != index2) {
336  T tmp = data_[index1];
337  data_[index1] = data_[index2];
338  data_[index2] = tmp;
339  }
340  }

◆ truncate()

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

Definition at line 137 of file genericvector.h.

137  {
138  if (size < size_used_) {
139  size_used_ = size;
140  }
141  }

◆ unsigned_size()

template<typename T >
size_t GenericVector< T >::unsigned_size ( ) const
inline

Definition at line 76 of file genericvector.h.

76  {
77  static_assert(sizeof(size_used_) <= sizeof(size_t),
78  "Wow! sizeof(size_t) < sizeof(int32_t)!!");
79  assert(0 <= size_used_);
80  return static_cast<size_t>(size_used_);
81  }

◆ WithinBounds()

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

Definition at line 343 of file genericvector.h.

343  {
344  for (int i = 0; i < size_used_; ++i) {
345  if (data_[i] < rangemin || rangemax < data_[i]) {
346  return false;
347  }
348  }
349  return true;
350  }

◆ write()

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

Definition at line 919 of file genericvector.h.

920  {
921  if (fwrite(&size_reserved_, sizeof(size_reserved_), 1, f) != 1) {
922  return false;
923  }
924  if (fwrite(&size_used_, sizeof(size_used_), 1, f) != 1) {
925  return false;
926  }
927  if (cb != nullptr) {
928  for (int i = 0; i < size_used_; ++i) {
929  if (!cb->Run(f, data_[i])) {
930  delete cb;
931  return false;
932  }
933  }
934  delete cb;
935  } else {
936  if (fwrite(data_, sizeof(T), size_used_, f) != unsigned_size()) {
937  return false;
938  }
939  }
940  return true;
941 }

Member Data Documentation

◆ clear_cb_

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

Definition at line 366 of file genericvector.h.

◆ compare_cb_

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

Definition at line 368 of file genericvector.h.

◆ data_

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

Definition at line 365 of file genericvector.h.

◆ kDefaultVectorSize

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

Definition at line 362 of file genericvector.h.

◆ size_reserved_

template<typename T >
int32_t GenericVector< T >::size_reserved_ {}
protected

Definition at line 364 of file genericvector.h.

◆ size_used_

template<typename T >
int32_t GenericVector< T >::size_used_ {}
protected

Definition at line 363 of file genericvector.h.


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