tesseract::PointerVector< T > Class Template Reference

#include <genericvector.h>

Inheritance diagram for tesseract::PointerVector< T >:

Public Member Functions
	PointerVector ()
	PointerVector (int size)
	~PointerVector ()
	PointerVector (const PointerVector &other)
PointerVector< T > &	operator+= (const PointerVector &other)
PointerVector< T > &	operator= (const PointerVector &other)
void	remove (int index)
void	truncate (int size)
void	compact (TessResultCallback1< bool, const T *> *delete_cb)
void	clear ()
bool	Serialize (FILE *fp) const
bool	Serialize (TFile *fp) const
bool	DeSerialize (bool swap, FILE *fp)
bool	DeSerialize (bool swap, TFile *fp)
bool	DeSerializeElement (bool swap, TFile *fp)
void	sort ()
Public Member Functions inherited from GenericVector< T *>
	GenericVector ()
	GenericVector (int size, T * init_val)
	GenericVector (const GenericVector &other)
GenericVector< T * > &	operator+= (const GenericVector &other)
void	operator+= (T * t)
GenericVector< T * > &	operator= (const GenericVector &other)
	~GenericVector ()
void	reserve (int size)
void	double_the_size ()
void	init_to_size (int size, T * t)
void	resize_no_init (int size)
int	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 (T * object) const
bool	contains (T * object) const
T *	contains_index (int index) const
int	push_back (T * object)
int	push_back_new (T * object)
int	push_front (T * object)
void	set (T * t, int index)
void	insert (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 (FILE *f, TessResultCallback3< bool, FILE *, T * *, bool > *cb, bool swap)
bool	Serialize (FILE *fp) const
bool	Serialize (tesseract::TFile *fp) const
bool	DeSerialize (bool swap, FILE *fp)
bool	DeSerialize (bool swap, tesseract::TFile *fp)
bool	SerializeClasses (FILE *fp) const
bool	SerializeClasses (tesseract::TFile *fp) const
bool	DeSerializeClasses (bool swap, FILE *fp)
bool	DeSerializeClasses (bool swap, 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	DeSerializeSize (bool swap, TFile *fp, inT32 *size)
static bool	DeSerializeSkip (bool swap, TFile *fp)
Static Public Member Functions inherited from GenericVector< T *>
static bool	SkipDeSerialize (bool swap, tesseract::TFile *fp)
static bool	SkipDeSerializeClasses (bool swap, tesseract::TFile *fp)
static T * *	double_the_size_memcpy (int current_size, T * *data)

Additional Inherited Members
Protected Member Functions inherited from GenericVector< T *>
int	choose_nth_item (int target_index, int start, int end, unsigned int *seed)
void	init (int size)
Protected Attributes inherited from GenericVector< T *>
inT32	size_used_
inT32	size_reserved_
T * *	data_
TessCallback1< T * > *	clear_cb_
TessResultCallback2< bool, T * const &, T * const &> *	compare_cb_
Static Protected Attributes inherited from GenericVector< T *>
static const int	kDefaultVectorSize

Detailed Description

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

Definition at line 432 of file genericvector.h.

Constructor & Destructor Documentation

PointerVector() [1/3]

template<typename T>

tesseract::PointerVector< T >::PointerVector ( )

inline

Definition at line 434 of file genericvector.h.

: GenericVector<T*>() { }

PointerVector() [2/3]

template<typename T>

tesseract::PointerVector< T >::PointerVector ( int  size )

inlineexplicit

Definition at line 435 of file genericvector.h.

: GenericVector<T*>(size) { }

~PointerVector()

template<typename T>

tesseract::PointerVector< T >::~PointerVector ( )

inline

Definition at line 436 of file genericvector.h.

                   {
    // Clear must be called here, even though it is called again by the base,
    // as the base will call the wrong clear.
    clear();
  }

PointerVector() [3/3]

template<typename T>

tesseract::PointerVector< T >::PointerVector ( const PointerVector< T > &  other )

inline

Definition at line 443 of file genericvector.h.

                                            : GenericVector<T*>(other) {
    this->init(other.size());
    this->operator+=(other);
  }

Member Function Documentation

clear()

template<typename T>

void tesseract::PointerVector< T >::clear ( )

inline

Definition at line 504 of file genericvector.h.

               {
    GenericVector<T*>::delete_data_pointers();
    GenericVector<T*>::clear();
  }

compact()

template<typename T>

void tesseract::PointerVector< T >::compact ( TessResultCallback1< bool, const T *> *  delete_cb )

inline

Definition at line 480 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 < GenericVector<T*>::size_used_ &&
           !delete_cb->Run(GenericVector<T*>::data_[old_index++]))
      ++new_size;
    // Now just copy anything else that gets false from delete_cb.
    for (; old_index < GenericVector<T*>::size_used_; ++old_index) {
      if (!delete_cb->Run(GenericVector<T*>::data_[old_index])) {
        GenericVector<T*>::data_[new_size++] =
            GenericVector<T*>::data_[old_index];
      } else {
        delete GenericVector<T*>::data_[old_index];
      }
    }
    GenericVector<T*>::size_used_ = new_size;
    delete delete_cb;
  }

DeSerialize() [1/2]

template<typename T>

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

inline

Definition at line 541 of file genericvector.h.

                                        {
    inT32 reserved;
    if (fread(&reserved, sizeof(reserved), 1, fp) != 1) return false;
    if (swap) Reverse32(&reserved);
    GenericVector<T*>::reserve(reserved);
    truncate(0);
    for (int i = 0; i < reserved; ++i) {
      inT8 non_null;
      if (fread(&non_null, sizeof(non_null), 1, fp) != 1) return false;
      T* item = NULL;
      if (non_null) {
        item = new T;
        if (!item->DeSerialize(swap, fp)) {
          delete item;
          return false;
        }
        this->push_back(item);
      } else {
        // Null elements should keep their place in the vector.
        this->push_back(NULL);
      }
    }
    return true;
  }

DeSerialize() [2/2]

template<typename T>

bool tesseract::PointerVector< T >::DeSerialize ( bool  swap, TFile *  fp  )

inline

Definition at line 565 of file genericvector.h.

                                         {
    inT32 reserved;
    if (!DeSerializeSize(swap, fp, &reserved)) return false;
    GenericVector<T*>::reserve(reserved);
    truncate(0);
    for (int i = 0; i < reserved; ++i) {
      if (!DeSerializeElement(swap, fp)) return false;
    }
    return true;
  }

DeSerializeElement()

template<typename T>

bool tesseract::PointerVector< T >::DeSerializeElement ( bool  swap, TFile *  fp  )

inline

Definition at line 585 of file genericvector.h.

                                                {
    inT8 non_null;
    if (fp->FRead(&non_null, sizeof(non_null), 1) != 1) return false;
    T* item = NULL;
    if (non_null) {
      item = new T;
      if (!item->DeSerialize(swap, fp)) {
        delete item;
        return false;
      }
      this->push_back(item);
    } else {
      // Null elements should keep their place in the vector.
      this->push_back(NULL);
    }
    return true;
  }

DeSerializeSize()

template<typename T>

static bool tesseract::PointerVector< T >::DeSerializeSize ( bool  swap, TFile *  fp, inT32 *  size  )

inlinestatic

Definition at line 579 of file genericvector.h.

                                                                 {
    if (fp->FRead(size, sizeof(*size), 1) != 1) return false;
    if (swap) Reverse32(size);
    return true;
  }

DeSerializeSkip()

template<typename T>

static bool tesseract::PointerVector< T >::DeSerializeSkip ( bool  swap, TFile *  fp  )

inlinestatic

Definition at line 603 of file genericvector.h.

                                                    {
    inT8 non_null;
    if (fp->FRead(&non_null, sizeof(non_null), 1) != 1) return false;
    if (non_null) {
      if (!T::SkipDeSerialize(swap, fp)) return false;
    }
    return true;
  }

operator+=()

template<typename T>

PointerVector<T>& tesseract::PointerVector< T >::operator+= ( const PointerVector< T > &  other )

inline

Definition at line 447 of file genericvector.h.

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

operator=()

template<typename T>

PointerVector<T>& tesseract::PointerVector< T >::operator= ( const PointerVector< T > &  other )

inline

Definition at line 455 of file genericvector.h.

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

remove()

template<typename T>

void tesseract::PointerVector< T >::remove ( int  index )

inline

Definition at line 465 of file genericvector.h.

                         {
    delete GenericVector<T*>::data_[index];
    GenericVector<T*>::remove(index);
  }

Serialize() [1/2]

template<typename T>

bool tesseract::PointerVector< T >::Serialize ( FILE *  fp ) const

inline

Definition at line 514 of file genericvector.h.

                                 {
    inT32 used = GenericVector<T*>::size_used_;
    if (fwrite(&used, sizeof(used), 1, fp) != 1) return false;
    for (int i = 0; i < used; ++i) {
      inT8 non_null = GenericVector<T*>::data_[i] != NULL;
      if (fwrite(&non_null, sizeof(non_null), 1, fp) != 1) return false;
      if (non_null && !GenericVector<T*>::data_[i]->Serialize(fp)) return false;
    }
    return true;
  }

Serialize() [2/2]

template<typename T>

bool tesseract::PointerVector< T >::Serialize ( TFile *  fp ) const

inline

Definition at line 524 of file genericvector.h.

                                  {
    inT32 used = GenericVector<T*>::size_used_;
    if (fp->FWrite(&used, sizeof(used), 1) != 1) return false;
    for (int i = 0; i < used; ++i) {
      inT8 non_null = GenericVector<T*>::data_[i] != NULL;
      if (fp->FWrite(&non_null, sizeof(non_null), 1) != 1) return false;
      if (non_null && !GenericVector<T*>::data_[i]->Serialize(fp)) return false;
    }
    return true;
  }

sort()

template<typename T>

void tesseract::PointerVector< T >::sort ( )

inline

Definition at line 614 of file genericvector.h.

{ this->GenericVector<T*>::sort(&sort_ptr_cmp<T>); }

truncate()

template<typename T>

void tesseract::PointerVector< T >::truncate ( int  size )

inline

Definition at line 472 of file genericvector.h.

                          {
    for (int i = size; i < GenericVector<T*>::size_used_; ++i)
      delete GenericVector<T*>::data_[i];
    GenericVector<T*>::truncate(size);
  }

---

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

• ccutil/genericvector.h