20 #ifndef TESSERACT_CCUTIL_GENERICVECTOR_H_ 21 #define TESSERACT_CCUTIL_GENERICVECTOR_H_ 89 T &
get(
int index)
const;
119 void set(T t,
int index);
122 void insert(T t,
int index);
126 void remove(
int index);
200 T *data_new =
new T[current_size * 2];
201 memcpy(data_new, data,
sizeof(T) * current_size);
223 void sort(
int (*comparator)(
const void*,
const void*)) {
234 return data_[index] == target;
245 while (top - bottom > 1) {
246 int middle = (bottom + top) / 2;
247 if (
data_[middle] > target)
278 while (old_index < size_used_ && !delete_cb->Run(old_index++))
282 if (!delete_cb->
Run(old_index)) {
291 T result =
static_cast<T
>(0);
303 if (target_index < 0)
307 unsigned int seed = 1;
312 void swap(
int index1,
int index2) {
313 if (index1 != index2) {
314 T tmp =
data_[index1];
323 if (
data_[i] < rangemin || rangemax <
data_[i])
331 int choose_nth_item(
int target_index,
int start,
int end,
unsigned int* seed);
362 FILE* fp = fopen(
filename.string(),
"rb");
364 fseek(fp, 0, SEEK_END);
365 size_t size = ftell(fp);
366 fseek(fp, 0, SEEK_SET);
369 result = fread(&(*data)[0], 1, size, fp) == size;
379 FILE* fp = fopen(
filename.string(),
"wb");
380 if (fp == NULL)
return false;
382 static_cast<int>(fwrite(&data[0], 1, data.
size(), fp)) == data.
size();
387 template <
typename T>
388 bool cmp_eq(T
const & t1, T
const & t2) {
396 template <
typename T>
398 const T* a =
static_cast<const T *
> (t1);
399 const T* b =
static_cast<const T *
> (t2);
402 }
else if (*b < *a) {
413 template <
typename T>
415 const T* a = *
reinterpret_cast<T *
const *
>(t1);
416 const T* b = *
reinterpret_cast<T *
const *
>(t2);
419 }
else if (*b < *a) {
447 for (
int i = 0; i < other.
size(); ++i) {
454 if (&other !=
this) {
463 void remove(
int index) {
471 for (
int i =
size; i < GenericVector<T*>::size_used_; ++i)
486 for (; old_index < GenericVector<T*>::size_used_; ++old_index) {
514 if (fwrite(&used,
sizeof(used), 1, fp) != 1)
return false;
515 for (
int i = 0; i < used; ++i) {
517 if (fwrite(&non_null,
sizeof(non_null), 1, fp) != 1)
return false;
524 if (fp->
FWrite(&used,
sizeof(used), 1) != 1)
return false;
525 for (
int i = 0; i < used; ++i) {
527 if (fp->
FWrite(&non_null,
sizeof(non_null), 1) != 1)
return false;
541 if (fread(&reserved,
sizeof(reserved), 1, fp) != 1)
return false;
545 for (
int i = 0; i < reserved; ++i) {
547 if (fread(&non_null,
sizeof(non_null), 1, fp) != 1)
return false;
551 if (!item->DeSerialize(
swap, fp)) {
568 for (
int i = 0; i < reserved; ++i) {
585 if (fp->
FRead(&non_null,
sizeof(non_null), 1) != 1)
return false;
589 if (!item->DeSerialize(
swap, fp)) {
603 if (fp->
FRead(&non_null,
sizeof(non_null), 1) != 1)
return false;
605 if (!T::SkipDeSerialize(
swap, fp))
return false;
618 template <
typename T>
631 template <
typename T>
641 template <
typename T>
648 template <
typename T>
650 if (size_reserved_ >= size || size <= 0)
652 if (size < kDefaultVectorSize) size = kDefaultVectorSize;
653 T* new_array =
new T[size];
654 for (
int i = 0; i < size_used_; ++i)
655 new_array[i] = data_[i];
658 size_reserved_ = size;
661 template <
typename T>
663 if (size_reserved_ == 0) {
664 reserve(kDefaultVectorSize);
667 reserve(2 * size_reserved_);
672 template <
typename T>
676 for (
int i = 0; i < size; ++i)
682 template <
typename T>
688 template <
typename T>
690 assert(index >= 0 && index < size_used_);
694 template <
typename T>
697 return data_[size_used_ - 1];
700 template <
typename T>
703 return data_[--size_used_];
707 template <
typename T>
716 template <
typename T>
719 if (size_reserved_ == size_used_)
721 for (
int i = size_used_; i > index; --i) {
722 data_[i] = data_[i-1];
730 template <
typename T>
733 for (
int i = index; i < size_used_ - 1; ++i) {
734 data_[i] = data_[i+1];
740 template <
typename T>
742 return index >= 0 && index < size_used_;
746 template <
typename T>
748 for (
int i = 0; i < size_used_; ++i) {
750 if (compare_cb_->Run(
object, data_[i]))
757 template <
typename T>
759 return get_index(
object) != -1;
763 template <
typename T>
766 if (size_used_ == size_reserved_)
768 index = size_used_++;
769 data_[index] = object;
773 template <
typename T>
775 int index = get_index(
object);
778 return push_back(
object);
782 template <
typename T>
784 if (size_used_ == size_reserved_)
786 for (
int i = size_used_; i > 0; --i)
787 data_[i] = data_[i-1];
793 template <
typename T>
798 template <
typename T>
801 for (
int i = 0; i < other.
size(); ++i) {
807 template <
typename T>
809 if (&other !=
this) {
818 template <
typename T>
825 template <
typename T>
832 template <
typename T>
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]);
843 if (clear_cb_ != NULL) {
847 if (compare_cb_ != NULL) {
853 template <
typename T>
855 for (
int i = 0; i < size_used_; ++i)
862 template <
typename T>
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;
868 for (
int i = 0; i < size_used_; ++i) {
869 if (!cb->
Run(f, data_[i])) {
876 if (fwrite(data_,
sizeof(T), size_used_, f) != size_used_)
return false;
881 template <
typename T>
886 if (fread(&reserved,
sizeof(reserved), 1, f) != 1)
return false;
889 if (fread(&size_used_,
sizeof(size_used_), 1, f) != 1)
return false;
892 for (
int i = 0; i < size_used_; ++i) {
893 if (!cb->
Run(f, data_ + i, swap)) {
900 if (fread(data_,
sizeof(T), size_used_, f) != size_used_)
return false;
902 for (
int i = 0; i < size_used_; ++i)
911 template <
typename T>
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;
917 template <
typename T>
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;
928 template <
typename T>
931 if (fread(&reserved,
sizeof(reserved), 1, fp) != 1)
return false;
934 size_used_ = reserved;
935 if (fread(data_,
sizeof(T), size_used_, fp) != size_used_)
return false;
937 for (
int i = 0; i < size_used_; ++i)
938 ReverseN(&data_[i],
sizeof(data_[i]));
942 template <
typename T>
945 if (fp->
FRead(&reserved,
sizeof(reserved), 1) != 1)
return false;
948 size_used_ = reserved;
949 if (fp->
FRead(data_,
sizeof(T), size_used_) != size_used_)
return false;
951 for (
int i = 0; i < size_used_; ++i)
952 ReverseN(&data_[i],
sizeof(data_[i]));
956 template <
typename T>
959 if (fp->
FRead(&reserved,
sizeof(reserved), 1) != 1)
return false;
961 return fp->
FRead(NULL,
sizeof(T), reserved) == reserved;
967 template <
typename T>
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;
975 template <
typename T>
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;
989 template <
typename T>
992 if (fread(&reserved,
sizeof(reserved), 1, fp) != 1)
return false;
995 init_to_size(reserved, empty);
996 for (
int i = 0; i < reserved; ++i) {
997 if (!data_[i].DeSerialize(swap, fp))
return false;
1001 template <
typename T>
1004 if (fp->
FRead(&reserved,
sizeof(reserved), 1) != 1)
return false;
1007 init_to_size(reserved, empty);
1008 for (
int i = 0; i < reserved; ++i) {
1009 if (!data_[i].DeSerialize(swap, fp))
return false;
1013 template <
typename T>
1016 if (fp->
FRead(&reserved,
sizeof(reserved), 1) != 1)
return false;
1018 for (
int i = 0; i < reserved; ++i) {
1019 if (!T::SkipDeSerialize(swap, fp))
return false;
1026 template <
typename T>
1029 this->data_ = from->
data_;
1041 template <
typename T>
1043 sort(&tesseract::sort_cmp<T>);
1059 template <
typename T>
1061 unsigned int* seed) {
1063 int num_elements = end - start;
1065 if (num_elements <= 1)
1067 if (num_elements == 2) {
1068 if (data_[start] < data_[start + 1]) {
1069 return target_index > start ? start + 1 : start;
1071 return target_index > start ? start : start + 1;
1075 #ifndef rand_r // _MSC_VER, ANDROID 1077 #define rand_r(seed) rand() 1079 int pivot =
rand_r(seed) % num_elements + start;
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]) {
1093 swap(--prev_greater, next_sample);
1098 if (target_index < next_lesser)
1100 else if (target_index < prev_greater)
1107 #endif // TESSERACT_CCUTIL_GENERICVECTOR_H_ int sort_ptr_cmp(const void *t1, const void *t2)
TessResultCallback2< bool, T const &, T const & > * compare_cb_
bool DeSerializeElement(bool swap, TFile *fp)
PointerVector< T > & operator+=(const PointerVector &other)
int size_reserved() const
bool DeSerialize(bool swap, TFile *fp)
void compact(TessResultCallback1< bool, const T *> *delete_cb)
GenericVectorEqEq(int size)
void resize_no_init(int size)
static const int kDefaultVectorSize
static bool DeSerializeSkip(bool swap, TFile *fp)
_ConstTessMemberResultCallback_0_0< false, R, T1 >::base * NewPermanentTessCallback(const T1 *obj, R(T2::*member)() const)
int FWrite(const void *buffer, int size, int count)
void Reverse32(void *ptr)
void insert(T t, int index)
GenericVector< T > & operator+=(const GenericVector &other)
static T * double_the_size_memcpy(int current_size, T *data)
void swap(int index1, int index2)
ICOORD & operator+=(ICOORD &op1, const ICOORD &op2)
PointerVector< T > & operator=(const PointerVector &other)
bool contains(T object) const
bool Serialize(TFile *fp) const
GenericVector(int size, T init_val)
void move(GenericVector< T > *from)
GenericVector(const GenericVector &other)
int get_index(T object) const
int push_back_new(T object)
bool DeSerializeClasses(bool swap, FILE *fp)
static bool SkipDeSerialize(bool swap, tesseract::TFile *fp)
bool Serialize(FILE *fp) const
void set_compare_callback(TessResultCallback2< bool, T const &, T const &> *cb)
T dot_product(const GenericVector< T > &other) const
inT32 choose_nth_item(inT32 index, float *array, inT32 count)
virtual R Run(A1, A2, A3)=0
bool LoadDataFromFile(const STRING &filename, GenericVector< char > *data)
T & operator[](int index) const
void set_clear_callback(TessCallback1< T > *cb)
PointerVector(const PointerVector &other)
int FRead(void *buffer, int size, int count)
TessCallback1< T > * clear_cb_
bool read(FILE *f, TessResultCallback3< bool, FILE *, T *, bool > *cb, bool swap)
void delete_data_pointers()
bool write(FILE *f, TessResultCallback2< bool, FILE *, T const &> *cb) const
static bool SkipDeSerializeClasses(bool swap, tesseract::TFile *fp)
bool SaveDataToFile(const GenericVector< char > &data, const STRING &filename)
bool WithinBounds(const T &rangemin, const T &rangemax) const
int binary_search(const T &target) const
static bool DeSerializeSize(bool swap, TFile *fp, inT32 *size)
bool SerializeClasses(FILE *fp) const
int choose_nth_item(int target_index)
T contains_index(int index) const
GenericVector< T > & operator=(const GenericVector &other)
bool(* FileReader)(const STRING &filename, GenericVector< char > *data)
bool cmp_eq(T const &t1, T const &t2)
void sort(int(*comparator)(const void *, const void *))
int sort_cmp(const void *t1, const void *t2)
bool DeSerialize(bool swap, FILE *fp)
void ReverseN(void *ptr, int num_bytes)
void init_to_size(int size, T t)
bool(* FileWriter)(const GenericVector< char > &data, const STRING &filename)
void compact(TessResultCallback1< bool, int > *delete_cb)
bool bool_binary_search(const T &target) const
bool Serialize(FILE *fp) const
bool DeSerialize(bool swap, FILE *fp)