Tesseract 3.02

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Hierarchy
- Class Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes
GenericVector< T > Class Template Reference

`#include <genericvector.h>`

Inheritance diagram for GenericVector< T >:

List of all members.

## Public Member Functions

| GenericVector ()
| GenericVector (int size)
| GenericVector (const GenericVector &other)
GenericVector< T > & | operator+= (const GenericVector &other)
GenericVector< T > & | operator= (const GenericVector &other)
virtual | ~GenericVector ()
void | reserve (int size)
void | double_the_size ()
void | init_to_size (int size, T t)
int | size () const
int | length () const
bool | empty () const
T & | get (int index) const
T & | back () const
T & | operator[] (int index) const
int | get_index (T object) const
bool | contains (T object) const
T | contains_index (int index) const
int | push_back (T object)
void | operator+= (T t)
int | push_back_new (T object)
int | push_front (T object)
void | set (T t, int index)
void | insert (T t, int index)
virtual void | remove (int index)
virtual void | truncate (int size)
void | set_clear_callback (TessCallback1< T > *cb)
void | set_compare_callback (TessResultCallback2< bool, T const &, T const & > *cb)
virtual void | clear ()
void | delete_data_pointers ()
void | move (GenericVector< T > *from)
bool | write (FILE *f, TessResultCallback2< bool, FILE *, T const & > *cb) const
bool | read (FILE *f, TessResultCallback3< bool, FILE *, T *, bool > *cb, bool swap)
virtual bool | Serialize (FILE *fp) const
virtual bool | DeSerialize (bool swap, FILE *fp)
bool | SerializeClasses (FILE *fp) const
bool | DeSerializeClasses (bool swap, FILE *fp)
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

## 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 | size_used_
inT32 | 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 35 of file genericvector.h.

## Constructor & Destructor Documentation

template<typename T>

GenericVector< T >::GenericVector | ( |  | ) |

inline

Definition at line 37 of file genericvector.h.

{ this->init(kDefaultVectorSize); }
template<typename T>

GenericVector< T >::GenericVector | ( | int | size | ) |

inlineexplicit

Definition at line 38 of file genericvector.h.

{ this->init(size); }
template<typename T>

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

inline

Definition at line 41 of file genericvector.h.

{
this->init(other.size());
this->operator+=(other);
}
template<typename T >

GenericVector< T >::~GenericVector | ( |  | ) |

virtual

Definition at line 471 of file genericvector.h.

{
clear();
}

## Member Function Documentation

template<typename T >

T & GenericVector< T >::back | ( |  | ) | const

Definition at line 522 of file genericvector.h.

{
ASSERT_HOST(size_used_ > 0);
return data_[size_used_ - 1];
}
template<typename T>

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

inline

Definition at line 209 of file genericvector.h.

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

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

inline

Definition at line 197 of file genericvector.h.

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

void GenericVector< T >::clear | ( |  | ) |

virtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< TrainingSample >, tesseract::PointerVector< Shape >, and tesseract::DawgInfoVector.

Definition at line 651 of file genericvector.h.

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

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

inline

Definition at line 242 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;
}
template<typename T>

void GenericVector< T >::compact_sorted | ( |  | ) |

inline

Definition at line 225 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;
}
template<typename T>

bool GenericVector< T >::contains | ( | T | object | ) | const

Definition at line 579 of file genericvector.h.

{
return get_index(object) != -1;
}
template<typename T >

T GenericVector< T >::contains_index | ( | int | index | ) | const

Definition at line 562 of file genericvector.h.

{
return index >= 0 && index < size_used_;
}
template<typename T >

void GenericVector< T >::delete_data_pointers | ( |  | ) |

Definition at line 672 of file genericvector.h.

{
for (int i = 0; i < size_used_; ++i)
if (data_[i]) {
delete data_[i];
}
}
template<typename T >

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

virtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< TrainingSample >, and tesseract::PointerVector< Shape >.

Definition at line 741 of file genericvector.h.

{
inT32 reserved;
if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
if (swap) Reverse32(&reserved);
reserve(reserved);
size_used_ = reserved;
if (fread(data_, sizeof(T), size_used_, fp) != size_used_) return false;
if (swap) {
for (int i = 0; i < size_used_; ++i)
ReverseN(&data_[i], sizeof(data_[i]));
}
return true;
}
template<typename T >

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

Definition at line 773 of file genericvector.h.

{
uinT32 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;
}
template<typename T>

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

inline

Definition at line 258 of file genericvector.h.

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

void GenericVector< T >::double_the_size | ( |  | ) |

Definition at line 490 of file genericvector.h.

{
if (size_reserved_ == 0) {
reserve(kDefaultVectorSize);
}
else {
reserve(2 * size_reserved_);
}
}
template<typename T>

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

inlinestatic

Definition at line 172 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;
}
template<typename T>

bool GenericVector< T >::empty | ( |  | ) | const

inline

Definition at line 68 of file genericvector.h.

{
return size_used_ == 0;
}
template<typename T >

T & GenericVector< T >::get | ( | int | index | ) | const

Definition at line 511 of file genericvector.h.

{
ASSERT_HOST(index >= 0 && index < size_used_);
return data_[index];
}
template<typename T>

int GenericVector< T >::get_index | ( | T | object | ) | const

Definition at line 568 of file genericvector.h.

{
for (int i = 0; i < size_used_; ++i) {
ASSERT_HOST(compare_cb_ != NULL);
if (compare_cb_->Run(object, data_[i]))
return i;
}
return -1;
}
template<typename T >

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

protected

Definition at line 461 of file genericvector.h.

{
size_used_ = 0;
size_reserved_ = 0;
data_ = 0;
clear_cb_ = 0;
compare_cb_ = 0;
reserve(size);
}
template<typename T>

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

Definition at line 501 of file genericvector.h.

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

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

Definition at line 538 of file genericvector.h.

{
ASSERT_HOST(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_++;
}
template<typename T>

int GenericVector< T >::length | ( |  | ) | const

inline

Definition at line 63 of file genericvector.h.

{
return size_used_;
}
template<typename T>

void GenericVector< T >::move | ( | GenericVector< T > * | from | ) |

Definition at line 788 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_ = NULL;
from->clear_cb_ = NULL;
from->compare_cb_ = NULL;
from->size_used_ = 0;
from->size_reserved_ = 0;
}
template<typename T >

GenericVector< T > & GenericVector< T >::operator+= | ( | const GenericVector< T > & | other | ) |

Definition at line 620 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;
}
template<typename T>

void GenericVector< T >::operator+= | ( | T | t | ) |

Definition at line 615 of file genericvector.h.

{
push_back(t);
}
template<typename T >

GenericVector< T > & GenericVector< T >::operator= | ( | const GenericVector< T > & | other | ) |

Definition at line 629 of file genericvector.h.

{
this->truncate(0);
this->operator+=(other);
return *this;
}
template<typename T >

T & GenericVector< T >::operator[] | ( | int | index | ) | const

Definition at line 517 of file genericvector.h.

{
return data_[index];
}
template<typename T>

int GenericVector< T >::push_back | ( | T | object | ) |

Definition at line 585 of file genericvector.h.

{
int index = 0;
if (size_used_ == size_reserved_)
double_the_size();
index = size_used_++;
data_[index] = object;
return index;
}
template<typename T>

int GenericVector< T >::push_back_new | ( | T | object | ) |

Definition at line 595 of file genericvector.h.

{
int index = get_index(object);
if (index >= 0)
return index;
return push_back(object);
}
template<typename T>

int GenericVector< T >::push_front | ( | T | object | ) |

Definition at line 604 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;
}
template<typename T>

bool GenericVector< T >::read | ( | FILE * | f,
|  | TessResultCallback3< bool, FILE *, T *, bool > * | cb,
|  | bool | swap
| ) |  |

Definition at line 700 of file genericvector.h.

{
inT32 reserved;
if (fread(&reserved, sizeof(reserved), 1, f) != 1) return false;
if (swap) Reverse32(&reserved);
reserve(reserved);
if (fread(&size_used_, sizeof(size_used_), 1, f) != 1) return false;
if (swap) Reverse32(&size_used_);
if (cb != NULL) {
for (int i = 0; i < size_used_; ++i) {
if (!cb->Run(f, data_ + i, swap)) {
delete cb;
return false;
}
}
delete cb;
} else {
if (fread(data_, sizeof(T), size_used_, f) != size_used_) return false;
if (swap) {
for (int i = 0; i < size_used_; ++i)
ReverseN(&data_[i], sizeof(T));
}
}
return true;
}
template<typename T >

void GenericVector< T >::remove | ( | int | index | ) |

virtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< TrainingSample >, and tesseract::PointerVector< Shape >.

Definition at line 552 of file genericvector.h.

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

void GenericVector< T >::reserve | ( | int | size | ) |

Definition at line 478 of file genericvector.h.

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

bool GenericVector< T >::Serialize | ( | FILE * | fp | ) | const

virtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< TrainingSample >, and tesseract::PointerVector< Shape >.

Definition at line 730 of file genericvector.h.

{
if (fwrite(&size_used_, sizeof(size_used_), 1, fp) != 1) return false;
if (fwrite(data_, sizeof(*data_), size_used_, fp) != size_used_) return false;
return true;
}
template<typename T >

bool GenericVector< T >::SerializeClasses | ( | FILE * | fp | ) | const

Definition at line 759 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;
}
template<typename T>

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

Definition at line 529 of file genericvector.h.

{
ASSERT_HOST(index >= 0 && index < size_used_);
data_[index] = t;
}
template<typename T>

void GenericVector< T >::set_clear_callback | ( | TessCallback1< T > * | cb | ) |

Definition at line 638 of file genericvector.h.

{
clear_cb_ = cb;
}
template<typename T>

void GenericVector< T >::set_compare_callback | ( | TessResultCallback2< bool, T const &, T const & > * | cb | ) |

Definition at line 645 of file genericvector.h.

{
compare_cb_ = cb;
}
template<typename T>

int GenericVector< T >::size | ( |  | ) | const

inline

Definition at line 59 of file genericvector.h.

{
return size_used_;
}
template<typename T >

void GenericVector< T >::sort | ( |  | ) |

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< TrainingSample >, and tesseract::PointerVector< Shape >.

Definition at line 803 of file genericvector.h.

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

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

inline

Definition at line 190 of file genericvector.h.

{
qsort(data_, size_used_, sizeof(*data_), comparator);
}
template<typename T>

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

inlinevirtual

Reimplemented in tesseract::PointerVector< T >, tesseract::PointerVector< TrainingSample >, and tesseract::PointerVector< Shape >.

Definition at line 112 of file genericvector.h.

{
if (size < size_used_)
size_used_ = size;
}
template<typename T>

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

Definition at line 681 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 != NULL) {
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) != size_used_) return false;
}
return true;
}

## Member Data Documentation

template<typename T>

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

protected

Definition at line 277 of file genericvector.h.

template<typename T>

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

mutableprotected

Definition at line 279 of file genericvector.h.

template<typename T>

T* GenericVector< T >::data_

protected

Definition at line 276 of file genericvector.h.

template<typename T>

const int GenericVector< T >::kDefaultVectorSize = 4

staticprotected

Definition at line 273 of file genericvector.h.

template<typename T>

inT32 GenericVector< T >::size_reserved_

protected

Definition at line 275 of file genericvector.h.

template<typename T>

inT32 GenericVector< T >::size_used_

protected

Definition at line 274 of file genericvector.h.

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

- /mnt/data/src/tesseract-ocr/ccutil/genericvector.h