19 #ifndef TESSERACT_CCUTIL_GENERICVECTOR_H_
20 #define TESSERACT_CCUTIL_GENERICVECTOR_H_
79 static_assert(
sizeof(
size_used_) <=
sizeof(
size_t),
"Wow! sizeof(size_t) < sizeof(int32_t)!!");
93 T &
at(
int index)
const {
119 void set(
const T &t,
int index);
163 bool write(FILE *f, std::function<
bool(FILE *,
const T &)> cb)
const;
196 T *data_new =
new T[current_size * 2];
197 memcpy(data_new, data,
sizeof(T) * current_size);
220 void sort(
int (*comparator)(
const void *,
const void *)) {
233 while (top - bottom > 1) {
234 int middle = (bottom + top) / 2;
235 if (
data_[middle] > target) {
245 void swap(
int index1,
int index2) {
246 if (index1 != index2) {
247 T tmp =
data_[index1];
281 FILE *fp = fopen(filename,
"rb");
283 fseek(fp, 0, SEEK_END);
284 auto size = std::ftell(fp);
285 fseek(fp, 0, SEEK_SET);
287 if (size > 0 && size < LONG_MAX) {
291 result =
static_cast<long>(fread(&(*data)[0], 1, size, fp)) == size;
301 FILE *fp = fopen(filename,
"wb");
305 bool result = fwrite(&data[0], 1, data.
size(), fp) == data.
size();
310 template <
typename T>
319 template <
typename T>
321 const T *a =
static_cast<const T *
>(t1);
322 const T *b =
static_cast<const T *
>(t2);
336 template <
typename T>
338 const T *a = *
static_cast<T *
const *
>(t1);
339 const T *b = *
static_cast<T *
const *
>(t2);
352 template <
typename T>
370 for (
unsigned i = 0; i < other.
size(); ++i) {
377 if (&other !=
this) {
394 for (
int i =
size; i < GenericVector<T *>::size_used_; ++i) {
416 if (fwrite(&used,
sizeof(used), 1, fp) != 1) {
419 for (
int i = 0; i < used; ++i) {
421 if (fwrite(&non_null,
sizeof(non_null), 1, fp) != 1) {
432 if (fp->
FWrite(&used,
sizeof(used), 1) != 1) {
435 for (
int i = 0; i < used; ++i) {
437 if (fp->
FWrite(&non_null,
sizeof(non_null), 1) != 1) {
455 if (fread(&reserved,
sizeof(reserved), 1, fp) != 1) {
462 assert(reserved <= UINT16_MAX);
463 if (reserved > UINT16_MAX) {
468 for (uint32_t i = 0; i < reserved; ++i) {
470 if (fread(&non_null,
sizeof(non_null), 1, fp) != 1) {
476 if (!item->DeSerialize(
swap, fp)) {
496 template <
typename T>
503 if (size < kDefaultVectorSize) {
504 size = kDefaultVectorSize;
507 size_reserved_ = size;
512 template <
typename T>
519 template <
typename T>
521 if (size_reserved_ >= size || size <= 0) {
524 if (size < kDefaultVectorSize) {
525 size = kDefaultVectorSize;
527 T *new_array =
new T[size];
528 for (
int i = 0; i < size_used_; ++i) {
529 new_array[i] = data_[i];
533 size_reserved_ = size;
536 template <
typename T>
538 if (size_reserved_ == 0) {
539 reserve(kDefaultVectorSize);
541 reserve(2 * size_reserved_);
546 template <
typename T>
550 for (
int i = 0; i < size; ++i) {
555 template <
typename T>
557 init_to_size(size, t);
560 template <
typename T>
562 assert(index >= 0 && index < size_used_);
566 template <
typename T>
568 assert(size_used_ > 0);
569 return data_[size_used_ - 1];
572 template <
typename T>
574 assert(size_used_ > 0);
575 return data_[--size_used_];
579 template <
typename T>
581 assert(index >= 0 && index < size_used_);
588 template <
typename T>
590 assert(index >= 0 && index <= size_used_);
591 if (size_reserved_ == size_used_) {
594 for (
int i = size_used_; i > index; --i) {
595 data_[i] = data_[i - 1];
603 template <
typename T>
605 assert(index >= 0 && index < size_used_);
606 for (
int i = index; i < size_used_ - 1; ++i) {
607 data_[i] = data_[i + 1];
613 template <
typename T>
615 for (
int i = 0; i < size_used_; ++i) {
616 if (
object == data_[i]) {
624 template <
typename T>
627 if (size_used_ == size_reserved_) {
630 index = size_used_++;
631 data_[index] = object;
635 template <
typename T>
637 int index = get_index(
object);
641 return push_back(
object);
645 template <
typename T>
647 if (size_used_ == size_reserved_) {
650 for (
int i = size_used_; i > 0; --i) {
651 data_[i] = data_[i - 1];
658 template <
typename T>
663 template <
typename T>
666 for (
unsigned i = 0; i < other.
size(); ++i) {
672 template <
typename T>
674 if (&other !=
this) {
682 template <
typename T>
684 if (size_reserved_ > 0 && clear_cb_ !=
nullptr) {
685 for (
int i = 0; i < size_used_; ++i) {
696 template <
typename T>
698 for (
int i = 0; i < size_used_; ++i) {
703 template <
typename T>
705 if (fwrite(&size_reserved_,
sizeof(size_reserved_), 1, f) != 1) {
708 if (fwrite(&size_used_,
sizeof(size_used_), 1, f) != 1) {
712 for (
int i = 0; i < size_used_; ++i) {
713 if (!cb(f, data_[i])) {
718 if (fwrite(data_,
sizeof(T), size_used_, f) != unsigned_size()) {
725 template <
typename T>
728 if (f->
FReadEndian(&reserved,
sizeof(reserved), 1) != 1) {
732 if (f->
FReadEndian(&size_used_,
sizeof(size_used_), 1) != 1) {
736 for (
int i = 0; i < size_used_; ++i) {
737 if (!cb(f, data_ + i)) {
742 if (f->
FReadEndian(data_,
sizeof(T), size_used_) !=
static_cast<unsigned>(size_used_)) {
751 template <
typename T>
753 if (fwrite(&size_used_,
sizeof(size_used_), 1, fp) != 1) {
756 if (fwrite(data_,
sizeof(*data_), size_used_, fp) != unsigned_size()) {
761 template <
typename T>
763 if (fp->
FWrite(&size_used_,
sizeof(size_used_), 1) != 1) {
766 if (fp->
FWrite(data_,
sizeof(*data_), size_used_) != size_used_) {
776 template <
typename T>
779 if (fread(&reserved,
sizeof(reserved), 1, fp) != 1) {
786 assert(reserved <= UINT16_MAX);
787 if (reserved > UINT16_MAX) {
791 size_used_ = reserved;
792 if (fread(data_,
sizeof(T), size_used_, fp) != unsigned_size()) {
796 for (
int i = 0; i < size_used_; ++i) {
797 ReverseN(&data_[i],
sizeof(data_[i]));
802 template <
typename T>
805 if (fp->
FReadEndian(&reserved,
sizeof(reserved), 1) != 1) {
809 const uint32_t limit = 50000000;
810 assert(reserved <= limit);
811 if (reserved > limit) {
815 size_used_ = reserved;
816 return fp->
FReadEndian(data_,
sizeof(T), size_used_) == size_used_;
822 template <
typename T>
824 if (fwrite(&size_used_,
sizeof(size_used_), 1, fp) != 1) {
827 for (
int i = 0; i < size_used_; ++i) {
834 template <
typename T>
836 if (fp->
FWrite(&size_used_,
sizeof(size_used_), 1) != 1) {
839 for (
int i = 0; i < size_used_; ++i) {
852 template <
typename T>
855 if (fread(&reserved,
sizeof(reserved), 1, fp) != 1) {
862 init_to_size(reserved, empty);
863 for (
int i = 0; i < reserved; ++i) {
870 template <
typename T>
873 if (fp->
FReadEndian(&reserved,
sizeof(reserved), 1) != 1) {
877 init_to_size(reserved, empty);
878 for (
int i = 0; i < reserved; ++i) {
888 template <
typename T>
891 this->data_ = from->
data_;
895 from->
data_ =
nullptr;
901 template <
typename T>
void ReverseN(void *ptr, int num_bytes)
bool cmp_eq(T const &t1, T const &t2)
bool DeSerialize(bool swap, FILE *fp, std::vector< T > &data)
bool Serialize(FILE *fp, const std::vector< T > &data)
ICOORD & operator+=(ICOORD &op1, const ICOORD &op2)
int sort_cmp(const void *t1, const void *t2)
bool SaveDataToFile(const GenericVector< char > &data, const char *filename)
void Reverse32(void *ptr)
int sort_ptr_cmp(const void *t1, const void *t2)
bool LoadDataFromFile(const char *filename, GenericVector< char > *data)
size_t unsigned_size() const
void resize(int size, const T &t)
void resize_no_init(int size)
int push_back_new(const T &object)
void operator+=(const T &t)
GenericVector(int size, const T &init_val)
bool read(TFile *f, std::function< bool(TFile *, T *)> cb)
GenericVector(const GenericVector &other)
bool SerializeClasses(TFile *fp) const
void insert(const T &t, int index)
static const int kDefaultVectorSize
int get_index(const T &object) const
int binary_search(const T &target) const
bool DeSerializeClasses(TFile *fp)
bool Serialize(TFile *fp) const
std::function< void(T)> clear_cb_
void set_clear_callback(std::function< void(T)> cb)
void swap(int index1, int index2)
int push_front(const T &object)
void sort(int(*comparator)(const void *, const void *))
bool Serialize(FILE *fp) const
static T * double_the_size_memcpy(int current_size, T *data)
void set(const T &t, int index)
bool SerializeClasses(FILE *fp) const
GenericVector< T > & operator=(const GenericVector &other)
bool DeSerialize(TFile *fp)
int size_reserved() const
void move(GenericVector< T > *from)
void init_to_size(int size, const T &t)
GenericVector< T > & operator+=(const GenericVector &other)
bool write(FILE *f, std::function< bool(FILE *, const T &)> cb) const
bool DeSerializeClasses(bool swap, FILE *fp)
T & operator[](int index) const
void delete_data_pointers()
bool DeSerialize(bool swap, FILE *fp)
bool Serialize(FILE *fp) const
bool DeSerialize(bool swap, FILE *fp)
PointerVector(const PointerVector &other)
bool Serialize(TFile *fp) const
PointerVector< T > & operator=(const PointerVector &other)
PointerVector< T > & operator+=(const PointerVector &other)
size_t FWrite(const void *buffer, size_t size, size_t count)
size_t FReadEndian(void *buffer, size_t size, size_t count)