tesseract v5.3.3.20231005
Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
tesseract::GenericVector< T > Class Template Reference

#include <genericvector.h>

Public Member Functions

 GenericVector ()
 
 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 (int size, const T &t)
 
void resize_no_init (int size)
 
unsigned size () const
 
size_t unsigned_size () const
 
int size_reserved () const
 
bool empty () const
 
T & at (int index) const
 
T & back () const
 
T & operator[] (int index) const
 
T pop_back ()
 
int get_index (const T &object) const
 
int push_back (T object)
 
void operator+= (const T &t)
 
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 (const std::function< void(T)> &cb)
 
void clear ()
 
void delete_data_pointers ()
 
void move (GenericVector< T > *from)
 
bool write (FILE *f, const std::function< bool(FILE *, const T &)> &cb) const
 
bool read (TFile *f, const std::function< bool(TFile *, T *)> &cb)
 
bool Serialize (FILE *fp) const
 
bool Serialize (TFile *fp) const
 
bool DeSerialize (bool swap, FILE *fp)
 
bool DeSerialize (TFile *fp)
 
bool SerializeClasses (FILE *fp) const
 
bool DeSerializeClasses (TFile *fp)
 
void reverse ()
 
void sort ()
 
void sort (int(*comparator)(const void *, const void *))
 
void swap (int index1, int index2)
 

Protected Member Functions

void init (int size)
 

Protected Attributes

int32_t size_used_ {}
 
int32_t size_reserved_ {}
 
T * data_
 
std::function< void(T)> clear_cb_
 

Static Protected Attributes

static const int kDefaultVectorSize = 4
 

Detailed Description

template<typename T>
class tesseract::GenericVector< T >

Definition at line 39 of file genericvector.h.

Constructor & Destructor Documentation

◆ GenericVector() [1/2]

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

Definition at line 41 of file genericvector.h.

41 {
42 init(kDefaultVectorSize);
43 }
tesseract::GenericVector::kDefaultVectorSize
static const int kDefaultVectorSize
Definition: genericvector.h:224

◆ GenericVector() [2/2]

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

Definition at line 46 of file genericvector.h.

46 {
47 this->init(other.size());
48 this->operator+=(other);
49 }
tesseract::GenericVector::operator+=
GenericVector< T > & operator+=(const GenericVector &other)
Definition: genericvector.h:590

◆ ~GenericVector()

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

Definition at line 462 of file genericvector.h.

462 {
463 clear();
464}

Member Function Documentation

◆ at()

template<typename T >
T & tesseract::GenericVector< T >::at ( int  index) const
inline

Definition at line 89 of file genericvector.h.

89 {
90 assert(index >= 0 && index < size_used_);
91 return data_[index];
92 }

◆ back()

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

Definition at line 516 of file genericvector.h.

516 {
517 assert(size_used_ > 0);
518 return data_[size_used_ - 1];
519}

◆ clear()

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

Definition at line 609 of file genericvector.h.

609 {
610 if (size_reserved_ > 0 && clear_cb_ != nullptr) {
611 for (int i = 0; i < size_used_; ++i) {
612 clear_cb_(data_[i]);
613 }
614 }
615 delete[] data_;
616 data_ = nullptr;
617 size_used_ = 0;
618 size_reserved_ = 0;
619 clear_cb_ = nullptr;
620}
tesseract::GenericVector::clear_cb_
std::function< void(T)> clear_cb_
Definition: genericvector.h:228

◆ delete_data_pointers()

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

Definition at line 623 of file genericvector.h.

623 {
624 for (int i = 0; i < size_used_; ++i) {
625 delete data_[i];
626 }
627}

◆ DeSerialize() [1/2]

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

Definition at line 703 of file genericvector.h.

703 {
704 uint32_t reserved;
705 if (fread(&reserved, sizeof(reserved), 1, fp) != 1) {
706 return false;
707 }
708 if (swap) {
709 Reverse32(&reserved);
710 }
711 // Arbitrarily limit the number of elements to protect against bad data.
712 assert(reserved <= UINT16_MAX);
713 if (reserved > UINT16_MAX) {
714 return false;
715 }
716 reserve(reserved);
717 size_used_ = reserved;
718 if (fread(data_, sizeof(T), size_used_, fp) != unsigned_size()) {
719 return false;
720 }
721 if (swap) {
722 for (int i = 0; i < size_used_; ++i) {
723 ReverseN(&data_[i], sizeof(data_[i]));
724 }
725 }
726 return true;
727}
tesseract::ReverseN
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:184
tesseract::Reverse32
void Reverse32(void *ptr)
Definition: helpers.h:196
tesseract::GenericVector::unsigned_size
size_t unsigned_size() const
Definition: genericvector.h:74
tesseract::GenericVector::swap
void swap(int index1, int index2)
Definition: genericvector.h:199

◆ DeSerialize() [2/2]

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

Definition at line 729 of file genericvector.h.

729 {
730 uint32_t reserved;
731 if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
732 return false;
733 }
734 // Arbitrarily limit the number of elements to protect against bad data.
735 const uint32_t limit = 50000000;
736 assert(reserved <= limit);
737 if (reserved > limit) {
738 return false;
739 }
740 reserve(reserved);
741 size_used_ = reserved;
742 return fp->FReadEndian(data_, sizeof(T), size_used_) == size_used_;
743}

◆ DeSerializeClasses()

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

Definition at line 767 of file genericvector.h.

767 {
768 int32_t reserved;
769 if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
770 return false;
771 }
772 T empty;
773 init_to_size(reserved, empty);
774 for (int i = 0; i < reserved; ++i) {
775 if (!data_[i].DeSerialize(fp)) {
776 return false;
777 }
778 }
779 return true;
780}
tesseract::GenericVector::init_to_size
void init_to_size(int size, const T &t)
Definition: genericvector.h:496
tesseract::GenericVector::DeSerialize
bool DeSerialize(bool swap, FILE *fp)
Definition: genericvector.h:703

◆ double_the_size()

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

Definition at line 486 of file genericvector.h.

486 {
487 if (size_reserved_ == 0) {
488 reserve(kDefaultVectorSize);
489 } else {
490 reserve(2 * size_reserved_);
491 }
492}

◆ empty()

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

Definition at line 84 of file genericvector.h.

84 {
85 return size_used_ == 0;
86 }

◆ get_index()

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

Definition at line 563 of file genericvector.h.

563 {
564 for (int i = 0; i < size_used_; ++i) {
565 if (object == data_[i]) {
566 return i;
567 }
568 }
569 return -1;
570}

◆ init()

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

Definition at line 446 of file genericvector.h.

446 {
447 size_used_ = 0;
448 if (size <= 0) {
449 data_ = nullptr;
450 size_reserved_ = 0;
451 } else {
452 if (size < kDefaultVectorSize) {
453 size = kDefaultVectorSize;
454 }
455 data_ = new T[size];
456 size_reserved_ = size;
457 }
458 clear_cb_ = nullptr;
459}
tesseract::GenericVector::size
unsigned size() const
Definition: genericvector.h:70

◆ init_to_size()

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

Definition at line 496 of file genericvector.h.

496 {
497 reserve(size);
498 size_used_ = size;
499 for (int i = 0; i < size; ++i) {
500 data_[i] = t;
501 }
502}

◆ insert()

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

Definition at line 538 of file genericvector.h.

538 {
539 assert(index >= 0 && index <= size_used_);
540 if (size_reserved_ == size_used_) {
541 double_the_size();
542 }
543 for (int i = size_used_; i > index; --i) {
544 data_[i] = data_[i - 1];
545 }
546 data_[index] = t;
547 size_used_++;
548}

◆ move()

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

Definition at line 785 of file genericvector.h.

785 {
786 this->clear();
787 this->data_ = from->data_;
788 this->size_reserved_ = from->size_reserved_;
789 this->size_used_ = from->size_used_;
790 this->clear_cb_ = from->clear_cb_;
791 from->data_ = nullptr;
792 from->clear_cb_ = nullptr;
793 from->size_used_ = 0;
794 from->size_reserved_ = 0;
795}

◆ operator+=() [1/2]

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

Definition at line 590 of file genericvector.h.

590 {
591 this->reserve(size_used_ + other.size_used_);
592 for (unsigned i = 0; i < other.size(); ++i) {
593 this->operator+=(other.data_[i]);
594 }
595 return *this;
596}

◆ operator+=() [2/2]

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

Definition at line 585 of file genericvector.h.

585 {
586 push_back(t);
587}

◆ operator=()

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

Definition at line 599 of file genericvector.h.

599 {
600 if (&other != this) {
601 this->truncate(0);
602 this->operator+=(other);
603 }
604 return *this;
605}

◆ operator[]()

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

Definition at line 510 of file genericvector.h.

510 {
511 assert(index >= 0 && index < size_used_);
512 return data_[index];
513}

◆ pop_back()

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

Definition at line 522 of file genericvector.h.

522 {
523 assert(size_used_ > 0);
524 return data_[--size_used_];
525}

◆ push_back()

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

Definition at line 574 of file genericvector.h.

574 {
575 int index = 0;
576 if (size_used_ == size_reserved_) {
577 double_the_size();
578 }
579 index = size_used_++;
580 data_[index] = std::move(object);
581 return index;
582}

◆ read()

template<typename T >
bool tesseract::GenericVector< T >::read ( TFile *  f,
const std::function< bool(TFile *, T *)> &  cb 
)

Definition at line 652 of file genericvector.h.

652 {
653 int32_t reserved;
654 if (f->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
655 return false;
656 }
657 reserve(reserved);
658 if (f->FReadEndian(&size_used_, sizeof(size_used_), 1) != 1) {
659 return false;
660 }
661 if (cb != nullptr) {
662 for (int i = 0; i < size_used_; ++i) {
663 if (!cb(f, data_ + i)) {
664 return false;
665 }
666 }
667 } else {
668 if (f->FReadEndian(data_, sizeof(T), size_used_) != static_cast<unsigned>(size_used_)) {
669 return false;
670 }
671 }
672 return true;
673}

◆ remove()

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

Definition at line 553 of file genericvector.h.

553 {
554 assert(index >= 0 && index < size_used_);
555 for (int i = index; i < size_used_ - 1; ++i) {
556 data_[i] = data_[i + 1];
557 }
558 size_used_--;
559}

◆ reserve()

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

Definition at line 469 of file genericvector.h.

469 {
470 if (size_reserved_ >= size || size <= 0) {
471 return;
472 }
473 if (size < kDefaultVectorSize) {
474 size = kDefaultVectorSize;
475 }
476 T *new_array = new T[size];
477 for (int i = 0; i < size_used_; ++i) {
478 new_array[i] = data_[i];
479 }
480 delete[] data_;
481 data_ = new_array;
482 size_reserved_ = size;
483}

◆ resize()

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

Definition at line 505 of file genericvector.h.

505 {
506 init_to_size(size, t);
507}

◆ resize_no_init()

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

Definition at line 64 of file genericvector.h.

64 {
65 reserve(size);
66 size_used_ = size;
67 }

◆ reverse()

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

Definition at line 177 of file genericvector.h.

177 {
178 for (int i = 0; i < size_used_ / 2; ++i) {
179 std::swap(data_[i], data_[size_used_ - 1 - i]);
180 }
181 }

◆ Serialize() [1/2]

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

Definition at line 678 of file genericvector.h.

678 {
679 if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) {
680 return false;
681 }
682 if (fwrite(data_, sizeof(*data_), size_used_, fp) != unsigned_size()) {
683 return false;
684 }
685 return true;
686}

◆ Serialize() [2/2]

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

Definition at line 688 of file genericvector.h.

688 {
689 if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) {
690 return false;
691 }
692 if (fp->FWrite(data_, sizeof(*data_), size_used_) != size_used_) {
693 return false;
694 }
695 return true;
696}

◆ SerializeClasses()

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

Definition at line 749 of file genericvector.h.

749 {
750 if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) {
751 return false;
752 }
753 for (int i = 0; i < size_used_; ++i) {
754 if (!data_[i].Serialize(fp)) {
755 return false;
756 }
757 }
758 return true;
759}
tesseract::GenericVector::Serialize
bool Serialize(FILE *fp) const
Definition: genericvector.h:678

◆ set()

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

Definition at line 529 of file genericvector.h.

529 {
530 assert(index >= 0 && index < size_used_);
531 data_[index] = t;
532}

◆ set_clear_callback()

template<typename T >
void tesseract::GenericVector< T >::set_clear_callback ( const std::function< void(T)> &  cb)
inline

Definition at line 126 of file genericvector.h.

126 {
127 clear_cb_ = cb;
128 }

◆ size()

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

Definition at line 70 of file genericvector.h.

70 {
71 return size_used_;
72 }

◆ size_reserved()

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

Definition at line 79 of file genericvector.h.

79 {
80 return size_reserved_;
81 }

◆ sort() [1/2]

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

Definition at line 798 of file genericvector.h.

798 {
799 sort(&sort_cmp<T>);
800}

◆ sort() [2/2]

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

Definition at line 194 of file genericvector.h.

194 {
195 qsort(data_, size_used_, sizeof(*data_), comparator);
196 }

◆ swap()

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

Definition at line 199 of file genericvector.h.

199 {
200 if (index1 != index2) {
201 T tmp = data_[index1];
202 data_[index1] = data_[index2];
203 data_[index2] = tmp;
204 }
205 }

◆ truncate()

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

Definition at line 118 of file genericvector.h.

118 {
119 if (size < size_used_) {
120 size_used_ = size;
121 }
122 }

◆ unsigned_size()

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

Definition at line 74 of file genericvector.h.

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

◆ write()

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

Definition at line 630 of file genericvector.h.

630 {
631 if (fwrite(&size_reserved_, sizeof(size_reserved_), 1, f) != 1) {
632 return false;
633 }
634 if (fwrite(&size_used_, sizeof(size_used_), 1, f) != 1) {
635 return false;
636 }
637 if (cb != nullptr) {
638 for (int i = 0; i < size_used_; ++i) {
639 if (!cb(f, data_[i])) {
640 return false;
641 }
642 }
643 } else {
644 if (fwrite(data_, sizeof(T), size_used_, f) != unsigned_size()) {
645 return false;
646 }
647 }
648 return true;
649}

Member Data Documentation

◆ clear_cb_

template<typename T >
std::function<void(T)> tesseract::GenericVector< T >::clear_cb_
protected

Definition at line 228 of file genericvector.h.

◆ data_

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

Definition at line 227 of file genericvector.h.

◆ kDefaultVectorSize

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

Definition at line 224 of file genericvector.h.

◆ size_reserved_

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

Definition at line 226 of file genericvector.h.

◆ size_used_

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

Definition at line 225 of file genericvector.h.

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