tesseract 4.1.1
Loading...
Searching...
No Matches
GenericVector< T > Class Template Reference

#include <genericvector.h>

Inheritance diagram for GenericVector< T >:
GenericVectorEqEq< UNICHAR_ID > GenericVectorEqEq< ParagraphModel * > GenericVectorEqEq< tesseract::LineHypothesis > GenericVectorEqEq< int > tesseract::PointerVector< tesseract::BaselineRow > tesseract::PointerVector< tesseract::BaselineBlock > tesseract::PointerVector< tesseract::LanguageModelState > tesseract::PointerVector< tesseract::DocumentData > tesseract::PointerVector< tesseract::ImageData > tesseract::PointerVector< tesseract::NetworkIO > tesseract::PointerVector< GenericVector< double > > tesseract::PointerVector< tesseract::TransposedArray > tesseract::PointerVector< tesseract::Network > tesseract::PointerVector< RecodeBeam > tesseract::PointerVector< tesseract::Shape > tesseract::PointerVector< tesseract::TrainingSample > tesseract::PointerVector< WERD_RES > 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 {
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}

◆ 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);
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_) {
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_) {
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_) {
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}
virtual R Run(A1, A2)=0

◆ 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 {
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_) {
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: