tesseract  5.0.0
tesseract::GenericVector< T > Class Template Reference

#include <genericvector.h>

Inheritance diagram for tesseract::GenericVector< T >:
tesseract::PointerVector< tesseract::WERD_RES >

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 (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
 
pop_back ()
 
int get_index (const T &object) 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 (std::function< void(T)> cb)
 
void clear ()
 
void delete_data_pointers ()
 
void move (GenericVector< T > *from)
 
bool write (FILE *f, std::function< bool(FILE *, const T &)> cb) const
 
bool read (TFile *f, 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 SerializeClasses (TFile *fp) const
 
bool DeSerializeClasses (bool swap, FILE *fp)
 
bool DeSerializeClasses (TFile *fp)
 
void reverse ()
 
void sort ()
 
void sort (int(*comparator)(const void *, const void *))
 
int binary_search (const T &target) const
 
void swap (int index1, int index2)
 

Static Public Member Functions

static T * double_the_size_memcpy (int current_size, T *data)
 

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/3]

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

Definition at line 41 of file genericvector.h.

41  {
43  }
static const int kDefaultVectorSize

◆ GenericVector() [2/3]

template<typename T >
tesseract::GenericVector< T >::GenericVector ( int  size,
const T &  init_val 
)
inline

Definition at line 44 of file genericvector.h.

44  {
45  init(size);
46  init_to_size(size, init_val);
47  }
unsigned size() const
Definition: genericvector.h:74
void init_to_size(int size, const T &t)

◆ GenericVector() [3/3]

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

Definition at line 50 of file genericvector.h.

50  {
51  this->init(other.size());
52  this->operator+=(other);
53  }
GenericVector< T > & operator+=(const GenericVector &other)

◆ ~GenericVector()

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

Definition at line 513 of file genericvector.h.

513  {
514  clear();
515 }

Member Function Documentation

◆ at()

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

Definition at line 93 of file genericvector.h.

93  {
94  assert(index >= 0 && index < size_used_);
95  return data_[index];
96  }

◆ back()

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

Definition at line 567 of file genericvector.h.

567  {
568  assert(size_used_ > 0);
569  return data_[size_used_ - 1];
570 }

◆ binary_search()

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

Definition at line 230 of file genericvector.h.

230  {
231  int bottom = 0;
232  int top = size_used_;
233  while (top - bottom > 1) {
234  int middle = (bottom + top) / 2;
235  if (data_[middle] > target) {
236  top = middle;
237  } else {
238  bottom = middle;
239  }
240  }
241  return bottom;
242  }

◆ clear()

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

Definition at line 683 of file genericvector.h.

683  {
684  if (size_reserved_ > 0 && clear_cb_ != nullptr) {
685  for (int i = 0; i < size_used_; ++i) {
686  clear_cb_(data_[i]);
687  }
688  }
689  delete[] data_;
690  data_ = nullptr;
691  size_used_ = 0;
692  size_reserved_ = 0;
693  clear_cb_ = nullptr;
694 }
std::function< void(T)> clear_cb_

◆ delete_data_pointers()

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

Definition at line 697 of file genericvector.h.

697  {
698  for (int i = 0; i < size_used_; ++i) {
699  delete data_[i];
700  }
701 }

◆ DeSerialize() [1/2]

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

Definition at line 777 of file genericvector.h.

777  {
778  uint32_t reserved;
779  if (fread(&reserved, sizeof(reserved), 1, fp) != 1) {
780  return false;
781  }
782  if (swap) {
783  Reverse32(&reserved);
784  }
785  // Arbitrarily limit the number of elements to protect against bad data.
786  assert(reserved <= UINT16_MAX);
787  if (reserved > UINT16_MAX) {
788  return false;
789  }
790  reserve(reserved);
791  size_used_ = reserved;
792  if (fread(data_, sizeof(T), size_used_, fp) != unsigned_size()) {
793  return false;
794  }
795  if (swap) {
796  for (int i = 0; i < size_used_; ++i) {
797  ReverseN(&data_[i], sizeof(data_[i]));
798  }
799  }
800  return true;
801 }
void ReverseN(void *ptr, int num_bytes)
Definition: helpers.h:189
void Reverse32(void *ptr)
Definition: helpers.h:206
size_t unsigned_size() const
Definition: genericvector.h:78
void swap(int index1, int index2)

◆ DeSerialize() [2/2]

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

Definition at line 803 of file genericvector.h.

803  {
804  uint32_t reserved;
805  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
806  return false;
807  }
808  // Arbitrarily limit the number of elements to protect against bad data.
809  const uint32_t limit = 50000000;
810  assert(reserved <= limit);
811  if (reserved > limit) {
812  return false;
813  }
814  reserve(reserved);
815  size_used_ = reserved;
816  return fp->FReadEndian(data_, sizeof(T), size_used_) == size_used_;
817 }

◆ DeSerializeClasses() [1/2]

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

Definition at line 853 of file genericvector.h.

853  {
854  int32_t reserved;
855  if (fread(&reserved, sizeof(reserved), 1, fp) != 1) {
856  return false;
857  }
858  if (swap) {
859  Reverse32(&reserved);
860  }
861  T empty;
862  init_to_size(reserved, empty);
863  for (int i = 0; i < reserved; ++i) {
864  if (!data_[i].DeSerialize(swap, fp)) {
865  return false;
866  }
867  }
868  return true;
869 }
bool DeSerialize(bool swap, FILE *fp)

◆ DeSerializeClasses() [2/2]

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

Definition at line 871 of file genericvector.h.

871  {
872  int32_t reserved;
873  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
874  return false;
875  }
876  T empty;
877  init_to_size(reserved, empty);
878  for (int i = 0; i < reserved; ++i) {
879  if (!data_[i].DeSerialize(fp)) {
880  return false;
881  }
882  }
883  return true;
884 }

◆ double_the_size()

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

Definition at line 537 of file genericvector.h.

537  {
538  if (size_reserved_ == 0) {
540  } else {
541  reserve(2 * size_reserved_);
542  }
543 }

◆ double_the_size_memcpy()

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

Definition at line 195 of file genericvector.h.

195  {
196  T *data_new = new T[current_size * 2];
197  memcpy(data_new, data, sizeof(T) * current_size);
198  delete[] data;
199  return data_new;
200  }

◆ empty()

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

Definition at line 88 of file genericvector.h.

88  {
89  return size_used_ == 0;
90  }

◆ get_index()

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

Definition at line 614 of file genericvector.h.

614  {
615  for (int i = 0; i < size_used_; ++i) {
616  if (object == data_[i]) {
617  return i;
618  }
619  }
620  return -1;
621 }

◆ init()

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

Definition at line 497 of file genericvector.h.

497  {
498  size_used_ = 0;
499  if (size <= 0) {
500  data_ = nullptr;
501  size_reserved_ = 0;
502  } else {
503  if (size < kDefaultVectorSize) {
505  }
506  data_ = new T[size];
508  }
509  clear_cb_ = nullptr;
510 }

◆ init_to_size()

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

Definition at line 547 of file genericvector.h.

547  {
548  reserve(size);
549  size_used_ = size;
550  for (int i = 0; i < size; ++i) {
551  data_[i] = t;
552  }
553 }

◆ insert()

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

Definition at line 589 of file genericvector.h.

589  {
590  assert(index >= 0 && index <= size_used_);
591  if (size_reserved_ == size_used_) {
592  double_the_size();
593  }
594  for (int i = size_used_; i > index; --i) {
595  data_[i] = data_[i - 1];
596  }
597  data_[index] = t;
598  size_used_++;
599 }

◆ move()

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

Definition at line 889 of file genericvector.h.

889  {
890  this->clear();
891  this->data_ = from->data_;
892  this->size_reserved_ = from->size_reserved_;
893  this->size_used_ = from->size_used_;
894  this->clear_cb_ = from->clear_cb_;
895  from->data_ = nullptr;
896  from->clear_cb_ = nullptr;
897  from->size_used_ = 0;
898  from->size_reserved_ = 0;
899 }

◆ operator+=() [1/2]

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

Definition at line 664 of file genericvector.h.

664  {
665  this->reserve(size_used_ + other.size_used_);
666  for (unsigned i = 0; i < other.size(); ++i) {
667  this->operator+=(other.data_[i]);
668  }
669  return *this;
670 }

◆ operator+=() [2/2]

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

Definition at line 659 of file genericvector.h.

659  {
660  push_back(t);
661 }

◆ operator=()

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

Definition at line 673 of file genericvector.h.

673  {
674  if (&other != this) {
675  this->truncate(0);
676  this->operator+=(other);
677  }
678  return *this;
679 }

◆ operator[]()

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

Definition at line 561 of file genericvector.h.

561  {
562  assert(index >= 0 && index < size_used_);
563  return data_[index];
564 }

◆ pop_back()

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

Definition at line 573 of file genericvector.h.

573  {
574  assert(size_used_ > 0);
575  return data_[--size_used_];
576 }

◆ push_back()

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

Definition at line 625 of file genericvector.h.

625  {
626  int index = 0;
627  if (size_used_ == size_reserved_) {
628  double_the_size();
629  }
630  index = size_used_++;
631  data_[index] = object;
632  return index;
633 }

◆ push_back_new()

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

Definition at line 636 of file genericvector.h.

636  {
637  int index = get_index(object);
638  if (index >= 0) {
639  return index;
640  }
641  return push_back(object);
642 }
int get_index(const T &object) const

◆ push_front()

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

Definition at line 646 of file genericvector.h.

646  {
647  if (size_used_ == size_reserved_) {
648  double_the_size();
649  }
650  for (int i = size_used_; i > 0; --i) {
651  data_[i] = data_[i - 1];
652  }
653  data_[0] = object;
654  ++size_used_;
655  return 0;
656 }

◆ read()

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

Definition at line 726 of file genericvector.h.

726  {
727  int32_t reserved;
728  if (f->FReadEndian(&reserved, sizeof(reserved), 1) != 1) {
729  return false;
730  }
731  reserve(reserved);
732  if (f->FReadEndian(&size_used_, sizeof(size_used_), 1) != 1) {
733  return false;
734  }
735  if (cb != nullptr) {
736  for (int i = 0; i < size_used_; ++i) {
737  if (!cb(f, data_ + i)) {
738  return false;
739  }
740  }
741  } else {
742  if (f->FReadEndian(data_, sizeof(T), size_used_) != static_cast<unsigned>(size_used_)) {
743  return false;
744  }
745  }
746  return true;
747 }

◆ remove()

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

Definition at line 604 of file genericvector.h.

604  {
605  assert(index >= 0 && index < size_used_);
606  for (int i = index; i < size_used_ - 1; ++i) {
607  data_[i] = data_[i + 1];
608  }
609  size_used_--;
610 }

◆ reserve()

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

Definition at line 520 of file genericvector.h.

520  {
521  if (size_reserved_ >= size || size <= 0) {
522  return;
523  }
524  if (size < kDefaultVectorSize) {
526  }
527  T *new_array = new T[size];
528  for (int i = 0; i < size_used_; ++i) {
529  new_array[i] = data_[i];
530  }
531  delete[] data_;
532  data_ = new_array;
534 }

◆ resize()

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

Definition at line 556 of file genericvector.h.

556  {
557  init_to_size(size, t);
558 }

◆ resize_no_init()

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

Definition at line 68 of file genericvector.h.

68  {
69  reserve(size);
70  size_used_ = size;
71  }

◆ reverse()

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

Definition at line 203 of file genericvector.h.

203  {
204  for (int i = 0; i < size_used_ / 2; ++i) {
205  std::swap(data_[i], data_[size_used_ - 1 - i]);
206  }
207  }

◆ Serialize() [1/2]

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

Definition at line 752 of file genericvector.h.

752  {
753  if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) {
754  return false;
755  }
756  if (fwrite(data_, sizeof(*data_), size_used_, fp) != unsigned_size()) {
757  return false;
758  }
759  return true;
760 }

◆ Serialize() [2/2]

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

Definition at line 762 of file genericvector.h.

762  {
763  if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) {
764  return false;
765  }
766  if (fp->FWrite(data_, sizeof(*data_), size_used_) != size_used_) {
767  return false;
768  }
769  return true;
770 }

◆ SerializeClasses() [1/2]

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

Definition at line 823 of file genericvector.h.

823  {
824  if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) {
825  return false;
826  }
827  for (int i = 0; i < size_used_; ++i) {
828  if (!data_[i].Serialize(fp)) {
829  return false;
830  }
831  }
832  return true;
833 }
bool Serialize(FILE *fp) const

◆ SerializeClasses() [2/2]

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

Definition at line 835 of file genericvector.h.

835  {
836  if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) {
837  return false;
838  }
839  for (int i = 0; i < size_used_; ++i) {
840  if (!data_[i].Serialize(fp)) {
841  return false;
842  }
843  }
844  return true;
845 }

◆ set()

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

Definition at line 580 of file genericvector.h.

580  {
581  assert(index >= 0 && index < size_used_);
582  data_[index] = t;
583 }

◆ set_clear_callback()

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

Definition at line 138 of file genericvector.h.

138  {
139  clear_cb_ = cb;
140  }

◆ size()

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

Definition at line 74 of file genericvector.h.

74  {
75  return size_used_;
76  }

◆ size_reserved()

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

Definition at line 83 of file genericvector.h.

83  {
84  return size_reserved_;
85  }

◆ sort() [1/2]

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

Definition at line 902 of file genericvector.h.

902  {
903  sort(&sort_cmp<T>);
904 }

◆ sort() [2/2]

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

Definition at line 220 of file genericvector.h.

220  {
221  qsort(data_, size_used_, sizeof(*data_), comparator);
222  }

◆ swap()

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

Definition at line 245 of file genericvector.h.

245  {
246  if (index1 != index2) {
247  T tmp = data_[index1];
248  data_[index1] = data_[index2];
249  data_[index2] = tmp;
250  }
251  }

◆ truncate()

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

Definition at line 130 of file genericvector.h.

130  {
131  if (size < size_used_) {
132  size_used_ = size;
133  }
134  }

◆ unsigned_size()

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

Definition at line 78 of file genericvector.h.

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

◆ write()

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

Definition at line 704 of file genericvector.h.

704  {
705  if (fwrite(&size_reserved_, sizeof(size_reserved_), 1, f) != 1) {
706  return false;
707  }
708  if (fwrite(&size_used_, sizeof(size_used_), 1, f) != 1) {
709  return false;
710  }
711  if (cb != nullptr) {
712  for (int i = 0; i < size_used_; ++i) {
713  if (!cb(f, data_[i])) {
714  return false;
715  }
716  }
717  } else {
718  if (fwrite(data_, sizeof(T), size_used_, f) != unsigned_size()) {
719  return false;
720  }
721  }
722  return true;
723 }

Member Data Documentation

◆ clear_cb_

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

Definition at line 274 of file genericvector.h.

◆ data_

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

Definition at line 273 of file genericvector.h.

◆ kDefaultVectorSize

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

Definition at line 270 of file genericvector.h.

◆ size_reserved_

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

Definition at line 272 of file genericvector.h.

◆ size_used_

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

Definition at line 271 of file genericvector.h.


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