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 (std::function< 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 (TFile *fp)
bool	DeSerializeElement (TFile *fp)
void	sort ()
Public Member Functions inherited from GenericVector< T * >
	GenericVector ()
	GenericVector (int size, const T * &init_val)
	GenericVector (const GenericVector &other)
GenericVector< T * > &	operator+= (const GenericVector &other)
void	operator+= (const T * &t)
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
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)
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	set_compare_callback (std::function< bool(const T * &, const 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 (tesseract::TFile *f, std::function< 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 ()
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 (TFile *fp, int32_t *size)
static bool	DeSerializeSkip (TFile *fp)
Static Public Member Functions inherited from GenericVector< T * >
static bool	SkipDeSerialize (tesseract::TFile *fp)
static bool	SkipDeSerializeClasses (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_t	size_used_
int32_t	size_reserved_
T * *	data_
std::function< void(T *)>	clear_cb_
std::function< bool(const T * &, const T * &)>	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 417 of file genericvector.h.

Constructor & Destructor Documentation

PointerVector() [1/3]

template<typename T>

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

inline

Definition at line 419 of file genericvector.h.

: GenericVector<T*>() {}

PointerVector() [2/3]

template<typename T>

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

inlineexplicit

Definition at line 420 of file genericvector.h.

: GenericVector<T*>(size) {}

~PointerVector()

template<typename T>

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

inline

Definition at line 421 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 428 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 490 of file genericvector.h.

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

compact()

template<typename T>

void tesseract::PointerVector< T >::compact ( std::function< bool(const T *)>  delete_cb )

inline

Definition at line 466 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(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(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;
  }

DeSerialize() [1/2]

template<typename T>

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

inline

Definition at line 539 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;
    }
    GenericVector<T*>::reserve(reserved);
    truncate(0);
    for (uint32_t i = 0; i < reserved; ++i) {
      int8_t non_null;
      if (fread(&non_null, sizeof(non_null), 1, fp) != 1) {
        return false;
      }
      T* item = nullptr;
      if (non_null != 0) {
        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(nullptr);
      }
    }
    return true;
  }

DeSerialize() [2/2]

template<typename T>

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

inline

Definition at line 574 of file genericvector.h.

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

DeSerializeElement()

template<typename T>

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

inline

Definition at line 596 of file genericvector.h.

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

DeSerializeSize()

template<typename T>

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

inlinestatic

Definition at line 592 of file genericvector.h.

                                                        {
    return fp->FReadEndian(size, sizeof(*size), 1) == 1;
  }

DeSerializeSkip()

template<typename T>

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

inlinestatic

Definition at line 616 of file genericvector.h.

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

operator+=()

template<typename T>

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

inline

Definition at line 432 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 440 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 450 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 500 of file genericvector.h.

                                 {
    int32_t used = GenericVector<T*>::size_used_;
    if (fwrite(&used, sizeof(used), 1, fp) != 1) {
      return false;
    }
    for (int i = 0; i < used; ++i) {
      int8_t non_null = GenericVector<T*>::data_[i] != nullptr;
      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 516 of file genericvector.h.

                                  {
    int32_t used = GenericVector<T*>::size_used_;
    if (fp->FWrite(&used, sizeof(used), 1) != 1) {
      return false;
    }
    for (int i = 0; i < used; ++i) {
      int8_t non_null = GenericVector<T*>::data_[i] != nullptr;
      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 631 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 457 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:

• /tesseract/include/tesseract/genericvector.h