GenericVector< T > Class Template Reference

#include <baseapi.h>

Inheritance diagram for GenericVector< 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
T	pop_back ()
int	get_index (const T &object) const
bool	contains (const T &object) const
T	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)
T	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 37 of file baseapi.h.

Constructor & Destructor Documentation

GenericVector() [1/3]

template<typename T>

GenericVector< T >::GenericVector ( )

inline

Definition at line 39 of file genericvector.h.

                  {
    init(kDefaultVectorSize);
  }

GenericVector() [2/3]

template<typename T>

GenericVector< T >::GenericVector ( int  size, const T &  init_val  )

inline

Definition at line 42 of file genericvector.h.

                                             {
    init(size);
    init_to_size(size, init_val);
  }

GenericVector() [3/3]

template<typename T>

GenericVector< T >::GenericVector ( const GenericVector< T > &  other )

inline

Definition at line 48 of file genericvector.h.

                                            {
    this->init(other.size());
    this->operator+=(other);
  }

~GenericVector()

template<typename T >

GenericVector< T >::~GenericVector

(

)

Definition at line 677 of file genericvector.h.

                                 {
  clear();
}

Member Function Documentation

back()

template<typename T >

T & GenericVector< T >::back

(

)

const

Definition at line 730 of file genericvector.h.

                                {
  assert(size_used_ > 0);
  return data_[size_used_ - 1];
}

binary_search()

template<typename T>

int GenericVector< T >::binary_search ( const T &  target ) const

inline

Definition at line 250 of file genericvector.h.

                                           {
    int bottom = 0;
    int top = size_used_;
    while (top - bottom > 1) {
      int middle = (bottom + top) / 2;
      if (data_[middle] > target)
        top = middle;
      else
        bottom = middle;
    }
    return bottom;
  }

bool_binary_search()

template<typename T>

bool GenericVector< T >::bool_binary_search ( const T &  target ) const

inline

Definition at line 238 of file genericvector.h.

                                                 {
    int index = binary_search(target);
    if (index >= size_used_)
      return false;
    return data_[index] == target;
  }

choose_nth_item() [1/2]

template<typename T>

int GenericVector< T >::choose_nth_item ( int  target_index )

inline

Definition at line 309 of file genericvector.h.

                                        {
    // Make sure target_index is legal.
    if (target_index < 0)
      target_index = 0;                   // ensure legal
    else if (target_index >= size_used_)
      target_index = size_used_ - 1;
    unsigned int seed = 1;
    return choose_nth_item(target_index, 0, size_used_, &seed);
  }

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 1083 of file genericvector.h.

                                                          {
  // Number of elements to process.
  int num_elements = end - start;
  // Trivial cases.
  if (num_elements <= 1)
    return start;
  if (num_elements == 2) {
    if (data_[start] < data_[start + 1]) {
      return target_index > start ? start + 1 : start;
    } else {
      return target_index > start ? start : start + 1;
    }
  }
  // Place the pivot at start.
  #ifndef rand_r  // _MSC_VER, ANDROID
  srand(*seed);
  #define rand_r(seed) rand()
  #endif  // _MSC_VER
  int pivot = rand_r(seed) % num_elements + start;
  swap(pivot, start);
  // The invariant condition here is that items [start, next_lesser) are less
  // than the pivot (which is at index next_lesser) and items
  // [prev_greater, end) are greater than the pivot, with items
  // [next_lesser, prev_greater) being equal to the pivot.
  int next_lesser = start;
  int prev_greater = end;
  for (int next_sample = start + 1; next_sample < prev_greater;) {
    if (data_[next_sample] < data_[next_lesser]) {
      swap(next_lesser++, next_sample++);
    } else if (data_[next_sample] == data_[next_lesser]) {
      ++next_sample;
    } else {
      swap(--prev_greater, next_sample);
    }
  }
  // Now the invariant is set up, we recurse on just the section that contains
  // the desired index.
  if (target_index < next_lesser)
    return choose_nth_item(target_index, start, next_lesser, seed);
  else if (target_index < prev_greater)
    return next_lesser;          // In equal bracket.
  else
    return choose_nth_item(target_index, prev_greater, end, seed);
}

clear()

template<typename T >

void GenericVector< T >::clear

(

)

Definition at line 868 of file genericvector.h.

                             {
  if (size_reserved_ > 0 && clear_cb_ != nullptr) {
    for (int i = 0; i < size_used_; ++i)
      clear_cb_->Run(data_[i]);
  }
  delete[] data_;
  data_ = nullptr;
  size_used_ = 0;
  size_reserved_ = 0;
  delete clear_cb_;
  clear_cb_ = nullptr;
  delete compare_cb_;
  compare_cb_ = nullptr;
}

compact()

template<typename T>

void GenericVector< T >::compact ( TessResultCallback1< bool, int > *  delete_cb )

inline

Definition at line 282 of file genericvector.h.

                                                          {
    int new_size = 0;
    int old_index = 0;
    // Until the callback returns true, the elements stay the same.
    while (old_index < size_used_ && !delete_cb->Run(old_index++))
      ++new_size;
    // Now just copy anything else that gets false from delete_cb.
    for (; old_index < size_used_; ++old_index) {
      if (!delete_cb->Run(old_index)) {
        data_[new_size++] = data_[old_index];
      }
    }
    size_used_ = new_size;
    delete delete_cb;
  }

compact_sorted()

template<typename T>

void GenericVector< T >::compact_sorted ( )

inline

Definition at line 265 of file genericvector.h.

                        {
    if (size_used_ == 0)
      return;

    // First element is in no matter what, hence the i = 1.
    int last_write = 0;
    for (int i = 1; i < size_used_; ++i) {
      // Finds next unique item and writes it.
      if (data_[last_write] != data_[i])
        data_[++last_write] = data_[i];
    }
    // last_write is the index of a valid data cell, so add 1.
    size_used_ = last_write + 1;
  }

contains()

template<typename T>

bool GenericVector< T >::contains

(

const T &

object

)

const

Definition at line 793 of file genericvector.h.

                                                     {
  return get_index(object) != -1;
}

contains_index()

template<typename T >

T GenericVector< T >::contains_index

(

int

index

)

const

Definition at line 776 of file genericvector.h.

                                                  {
  return index >= 0 && index < size_used_;
}

delete_data_pointers()

template<typename T >

void GenericVector< T >::delete_data_pointers

(

)

Definition at line 884 of file genericvector.h.

                                            {
  for (int i = 0; i < size_used_; ++i) {
    delete data_[i];
  }
}

DeSerialize() [1/2]

template<typename T >

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

Definition at line 954 of file genericvector.h.

                                                      {
  uint32_t reserved;
  if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
  if (swap) Reverse32(&reserved);
  // Arbitrarily limit the number of elements to protect against bad data.
  assert(reserved <= UINT16_MAX);
  if (reserved > UINT16_MAX) return false;
  reserve(reserved);
  size_used_ = reserved;
  if (fread(data_, sizeof(T), size_used_, fp) != unsigned_size()) return false;
  if (swap) {
    for (int i = 0; i < size_used_; ++i)
      ReverseN(&data_[i], sizeof(data_[i]));
  }
  return true;
}

DeSerialize() [2/2]

template<typename T >

bool GenericVector< T >::DeSerialize

(

tesseract::TFile *

fp

)

Definition at line 971 of file genericvector.h.

                                                     {
  uint32_t reserved;
  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
  // Arbitrarily limit the number of elements to protect against bad data.
  const uint32_t limit = 50000000;
  assert(reserved <= limit);
  if (reserved > limit) return false;
  reserve(reserved);
  size_used_ = reserved;
  return fp->FReadEndian(data_, sizeof(T), size_used_) == size_used_;
}

DeSerializeClasses() [1/2]

template<typename T >

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

Definition at line 1015 of file genericvector.h.

                                                             {
  int32_t reserved;
  if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
  if (swap) Reverse32(&reserved);
  T empty;
  init_to_size(reserved, empty);
  for (int i = 0; i < reserved; ++i) {
    if (!data_[i].DeSerialize(swap, fp)) return false;
  }
  return true;
}

DeSerializeClasses() [2/2]

template<typename T >

bool GenericVector< T >::DeSerializeClasses

(

tesseract::TFile *

fp

)

Definition at line 1027 of file genericvector.h.

                                                            {
  int32_t reserved;
  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
  T empty;
  init_to_size(reserved, empty);
  for (int i = 0; i < reserved; ++i) {
    if (!data_[i].DeSerialize(fp)) return false;
  }
  return true;
}

dot_product()

template<typename T>

T GenericVector< T >::dot_product ( const GenericVector< T > &  other ) const

inline

Definition at line 298 of file genericvector.h.

                                                     {
    T result = static_cast<T>(0);
    for (int i = std::min(size_used_, other.size_used_) - 1; i >= 0; --i)
      result += data_[i] * other.data_[i];
    return result;
  }

double_the_size()

template<typename T >

void GenericVector< T >::double_the_size

(

)

Definition at line 697 of file genericvector.h.

                                       {
  if (size_reserved_ == 0) {
    reserve(kDefaultVectorSize);
  }
  else {
    reserve(2 * size_reserved_);
  }
}

double_the_size_memcpy()

template<typename T>

static T* GenericVector< T >::double_the_size_memcpy ( int  current_size, T *  data  )

inlinestatic

Definition at line 207 of file genericvector.h.

                                                              {
    T *data_new = new T[current_size * 2];
    memcpy(data_new, data, sizeof(T) * current_size);
    delete[] data;
    return data_new;
  }

empty()

template<typename T>

bool GenericVector< T >::empty ( ) const

inline

Definition at line 90 of file genericvector.h.

                     {
    return size_used_ == 0;
  }

get()

template<typename T >

T & GenericVector< T >::get

(

int

index

)

const

Definition at line 718 of file genericvector.h.

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

get_index()

template<typename T>

int GenericVector< T >::get_index

(

const T &

object

)

const

Definition at line 782 of file genericvector.h.

                                                     {
  for (int i = 0; i < size_used_; ++i) {
    assert(compare_cb_ != nullptr);
    if (compare_cb_->Run(object, data_[i]))
      return i;
  }
  return -1;
}

init()

template<typename T >

void GenericVector< T >::init ( int  size )

protected

Definition at line 662 of file genericvector.h.

                                    {
  size_used_ = 0;
  if (size <= 0) {
    data_ = nullptr;
    size_reserved_ = 0;
  } else {
    if (size < kDefaultVectorSize) size = kDefaultVectorSize;
    data_ = new T[size];
    size_reserved_ = size;
  }
  clear_cb_ = nullptr;
  compare_cb_ = nullptr;
}

init_to_size()

template<typename T>

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

Definition at line 708 of file genericvector.h.

                                                        {
  reserve(size);
  size_used_ = size;
  for (int i = 0; i < size; ++i)
    data_[i] = t;
}

insert()

template<typename T>

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

Definition at line 752 of file genericvector.h.

                                                   {
  assert(index >= 0 && index <= size_used_);
  if (size_reserved_ == size_used_)
    double_the_size();
  for (int i = size_used_; i > index; --i) {
    data_[i] = data_[i-1];
  }
  data_[index] = t;
  size_used_++;
}

length()

template<typename T>

int GenericVector< T >::length ( ) const

inline

Definition at line 85 of file genericvector.h.

                     {
    return size_used_;
  }

move()

template<typename T>

void GenericVector< T >::move

(

GenericVector< T > *

from

)

Definition at line 1050 of file genericvector.h.

                                                  {
  this->clear();
  this->data_ = from->data_;
  this->size_reserved_ = from->size_reserved_;
  this->size_used_ = from->size_used_;
  this->compare_cb_ = from->compare_cb_;
  this->clear_cb_ = from->clear_cb_;
  from->data_ = nullptr;
  from->clear_cb_ = nullptr;
  from->compare_cb_ = nullptr;
  from->size_used_ = 0;
  from->size_reserved_ = 0;
}

operator+=() [1/2]

template<typename T >

GenericVector< T > & GenericVector< T >::operator+=

(

const GenericVector< T > &

other

)

Definition at line 834 of file genericvector.h.

                                                                         {
  this->reserve(size_used_ + other.size_used_);
  for (int i = 0; i < other.size(); ++i) {
    this->operator+=(other.data_[i]);
  }
  return *this;
}

operator+=() [2/2]

template<typename T>

void GenericVector< T >::operator+=

(

const T &

t

)

Definition at line 829 of file genericvector.h.

                                            {
  push_back(t);
}

operator=()

template<typename T >

GenericVector< T > & GenericVector< T >::operator=

(

const GenericVector< T > &

other

)

Definition at line 843 of file genericvector.h.

                                                                        {
  if (&other != this) {
    this->truncate(0);
    this->operator+=(other);
  }
  return *this;
}

operator[]()

template<typename T >

T & GenericVector< T >::operator[]

(

int

index

)

const

Definition at line 724 of file genericvector.h.

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

pop_back()

template<typename T >

T GenericVector< T >::pop_back

(

)

Definition at line 736 of file genericvector.h.

                             {
  assert(size_used_ > 0);
  return data_[--size_used_];
}

push_back()

template<typename T>

int GenericVector< T >::push_back

(

T

object

)

Definition at line 799 of file genericvector.h.

                                        {
  int index = 0;
  if (size_used_ == size_reserved_)
    double_the_size();
  index = size_used_++;
  data_[index] = object;
  return index;
}

push_back_new()

template<typename T>

int GenericVector< T >::push_back_new

(

const T &

object

)

Definition at line 809 of file genericvector.h.

                                                   {
  int index = get_index(object);
  if (index >= 0)
    return index;
  return push_back(object);
}

push_front()

template<typename T>

int GenericVector< T >::push_front

(

const T &

object

)

Definition at line 818 of file genericvector.h.

                                                {
  if (size_used_ == size_reserved_)
    double_the_size();
  for (int i = size_used_; i > 0; --i)
    data_[i] = data_[i-1];
  data_[0] = object;
  ++size_used_;
  return 0;
}

read()

template<typename T>

bool GenericVector< T >::read	(	tesseract::TFile *	f,
		TessResultCallback2< bool, tesseract::TFile *, T *> *	cb
	)

Definition at line 912 of file genericvector.h.

                                                                           {
  int32_t reserved;
  if (f->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
  reserve(reserved);
  if (f->FReadEndian(&size_used_, sizeof(size_used_), 1) != 1) return false;
  if (cb != nullptr) {
    for (int i = 0; i < size_used_; ++i) {
      if (!cb->Run(f, data_ + i)) {
        delete cb;
        return false;
      }
    }
    delete cb;
  } else {
    if (f->FReadEndian(data_, sizeof(T), size_used_) != size_used_)
      return false;
  }
  return true;
}

remove()

template<typename T >

void GenericVector< T >::remove

(

int

index

)

Definition at line 766 of file genericvector.h.

                                       {
  assert(index >= 0 && index < size_used_);
  for (int i = index; i < size_used_ - 1; ++i) {
    data_[i] = data_[i+1];
  }
  size_used_--;
}

reserve()

template<typename T >

void GenericVector< T >::reserve

(

int

size

)

Definition at line 684 of file genericvector.h.

                                       {
  if (size_reserved_ >= size || size <= 0)
    return;
  if (size < kDefaultVectorSize) size = kDefaultVectorSize;
  T* new_array = new T[size];
  for (int i = 0; i < size_used_; ++i)
    new_array[i] = data_[i];
  delete[] data_;
  data_ = new_array;
  size_reserved_ = size;
}

resize_no_init()

template<typename T>

void GenericVector< T >::resize_no_init ( int  size )

inline

Definition at line 65 of file genericvector.h.

                                {
    reserve(size);
    size_used_ = size;
  }

reverse()

template<typename T>

void GenericVector< T >::reverse ( )

inline

Definition at line 215 of file genericvector.h.

                 {
    for (int i = 0; i < size_used_ / 2; ++i)
      Swap(&data_[i], &data_[size_used_ - 1 - i]);
  }

Serialize() [1/2]

template<typename T >

bool GenericVector< T >::Serialize

(

FILE *

fp

)

const

Definition at line 936 of file genericvector.h.

                                               {
  if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) return false;
  if (fwrite(data_, sizeof(*data_), size_used_, fp) != unsigned_size())
    return false;
  return true;
}

Serialize() [2/2]

template<typename T >

bool GenericVector< T >::Serialize

(

tesseract::TFile *

fp

)

const

Definition at line 943 of file genericvector.h.

                                                         {
  if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) return false;
  if (fp->FWrite(data_, sizeof(*data_), size_used_) != size_used_) return false;
  return true;
}

SerializeClasses() [1/2]

template<typename T >

bool GenericVector< T >::SerializeClasses

(

FILE *

fp

)

const

Definition at line 993 of file genericvector.h.

                                                      {
  if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) return false;
  for (int i = 0; i < size_used_; ++i) {
    if (!data_[i].Serialize(fp)) return false;
  }
  return true;
}

SerializeClasses() [2/2]

template<typename T >

bool GenericVector< T >::SerializeClasses

(

tesseract::TFile *

fp

)

const

Definition at line 1001 of file genericvector.h.

                                                                {
  if (fp->FWrite(&size_used_, sizeof(size_used_), 1) != 1) return false;
  for (int i = 0; i < size_used_; ++i) {
    if (!data_[i].Serialize(fp)) return false;
  }
  return true;
}

set()

template<typename T>

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

Definition at line 743 of file genericvector.h.

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

set_clear_callback()

template<typename T>

void GenericVector< T >::set_clear_callback

(

TessCallback1< T > *

cb

)

Definition at line 854 of file genericvector.h.

                                                              {
  clear_cb_ = cb;
}

set_compare_callback()

template<typename T>

void GenericVector< T >::set_compare_callback

(

TessResultCallback2< bool, T const &, T const &> *

cb

)

Definition at line 861 of file genericvector.h.

                                                         {
  compare_cb_ = cb;
}

size()

template<typename T>

int GenericVector< T >::size ( ) const

inline

Definition at line 71 of file genericvector.h.

                   {
    return size_used_;
  }

size_reserved()

template<typename T>

int GenericVector< T >::size_reserved ( ) const

inline

Definition at line 81 of file genericvector.h.

                            {
    return size_reserved_;
  }

SkipDeSerialize()

template<typename T >

bool GenericVector< T >::SkipDeSerialize ( tesseract::TFile *  fp )

static

Definition at line 983 of file genericvector.h.

                                                         {
  uint32_t reserved;
  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
  return fp->FRead(nullptr, sizeof(T), reserved) == reserved;
}

SkipDeSerializeClasses()

template<typename T >

bool GenericVector< T >::SkipDeSerializeClasses ( tesseract::TFile *  fp )

static

Definition at line 1038 of file genericvector.h.

                                                                {
  int32_t reserved;
  if (fp->FReadEndian(&reserved, sizeof(reserved), 1) != 1) return false;
  for (int i = 0; i < reserved; ++i) {
    if (!T::SkipDeSerialize(fp)) return false;
  }
  return true;
}

sort() [1/2]

template<typename T >

void GenericVector< T >::sort

(

)

Definition at line 1065 of file genericvector.h.

                            {
  sort(&tesseract::sort_cmp<T>);
}

sort() [2/2]

template<typename T>

void GenericVector< T >::sort ( int(*)(const void *, const void *)  comparator )

inline

Definition at line 231 of file genericvector.h.

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

swap()

template<typename T>

void GenericVector< T >::swap ( int  index1, int  index2  )

inline

Definition at line 320 of file genericvector.h.

                                    {
    if (index1 != index2) {
      T tmp = data_[index1];
      data_[index1] = data_[index2];
      data_[index2] = tmp;
    }
  }

truncate()

template<typename T>

void GenericVector< T >::truncate ( int  size )

inline

Definition at line 136 of file genericvector.h.

                          {
    if (size < size_used_)
      size_used_ = size;
  }

unsigned_size()

template<typename T>

size_t GenericVector< T >::unsigned_size ( ) const

inline

Definition at line 75 of file genericvector.h.

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

WithinBounds()

template<typename T>

bool GenericVector< T >::WithinBounds ( const T &  rangemin, const T &  rangemax  ) const

inline

Definition at line 329 of file genericvector.h.

                                                                {
    for (int i = 0; i < size_used_; ++i) {
      if (data_[i] < rangemin || rangemax < data_[i])
        return false;
    }
    return true;
  }

write()

template<typename T>

bool GenericVector< T >::write	(	FILE *	f,
		TessResultCallback2< bool, FILE *, T const &> *	cb
	)		const

Definition at line 892 of file genericvector.h.

                                                                    {
  if (fwrite(&size_reserved_, sizeof(size_reserved_), 1, f) != 1) return false;
  if (fwrite(&size_used_, sizeof(size_used_), 1, f) != 1) return false;
  if (cb != nullptr) {
    for (int i = 0; i < size_used_; ++i) {
      if (!cb->Run(f, data_[i])) {
        delete cb;
        return false;
      }
    }
    delete cb;
  } else {
    if (fwrite(data_, sizeof(T), size_used_, f) != unsigned_size())
      return false;
  }
  return true;
}

Member Data Documentation

clear_cb_

template<typename T>

TessCallback1<T>* GenericVector< T >::clear_cb_

protected

Definition at line 351 of file genericvector.h.

compare_cb_

template<typename T>

TessResultCallback2<bool, T const &, T const &>* GenericVector< T >::compare_cb_

mutableprotected

Definition at line 353 of file genericvector.h.

data_

template<typename T>

T* GenericVector< T >::data_

protected

Definition at line 350 of file genericvector.h.

kDefaultVectorSize

template<typename T>

const int GenericVector< T >::kDefaultVectorSize = 4

staticprotected

Definition at line 347 of file genericvector.h.

size_reserved_

template<typename T>

int32_t GenericVector< T >::size_reserved_

protected

Definition at line 349 of file genericvector.h.

size_used_

template<typename T>

int32_t GenericVector< T >::size_used_

protected

Definition at line 348 of file genericvector.h.

---

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

• /usr/src/tesseract-ocr.master/src/api/baseapi.h
• /usr/src/tesseract-ocr.master/src/ccutil/genericvector.h