G3D::SmallArray< T, N > Class Template Reference

#include <SmallArray.h>

Public Member Functions
	SmallArray ()
int	size () const
void	resize (int n, bool shrinkIfNecessary=true)
void	clear (bool shrinkIfNecessary=true)
void	clearAndSetMemoryManager (MemoryManager::Ref &m)
T &	operator[] (int i)
const T &	operator[] (int i) const
void	push (const T &v)
void	append (const T &v)
void	append (const T &v, const T &v2)
void	append (const T &v, const T &v2, const T &v3)
void	append (const T &v, const T &v2, const T &v3, const T &v4)
int	findIndex (const T &v)
void	fastRemove (int i, bool shrinkIfNecessary=false)
T	pop ()
void	popDiscard ()
T &	next ()
bool	contains (const T &value) const
template<int MIN_ELEMENTS>
SmallArray< T, N > &	operator= (const Array< T, MIN_ELEMENTS > &src)
const T &	last () const
T &	last ()

Private Attributes
int	m_size
T	m_embedded [N]
Array< T >	m_rest

Detailed Description

template<class T, int N>
class G3D::SmallArray< T, N >

Embeds N elements to reduce allocation time and increase memory coherence when working with arrays of arrays. Offers a limited subset of the functionality of G3D::Array.

Constructor & Destructor Documentation

template<class T, int N>

G3D::SmallArray< T, N >::SmallArray ( )

inline

: m_size(0) {}

Member Function Documentation

template<class T, int N>

void G3D::SmallArray< T, N >::append ( const T &  v )

inline

 {
 push(v);
 }

Here is the caller graph for this function:

template<class T, int N>

void G3D::SmallArray< T, N >::append ( const T &  v, const T &  v2  )

inline

 {
 push(v);
 push(v2);
 }

template<class T, int N>

void G3D::SmallArray< T, N >::append ( const T &  v, const T &  v2, const T &  v3  )

inline

 {
 push(v);
 push(v2);
 push(v3);
 }

template<class T, int N>

void G3D::SmallArray< T, N >::append ( const T &  v, const T &  v2, const T &  v3, const T &  v4  )

inline

 {
 push(v);
 push(v2);
 push(v3);
 push(v4);
 }

template<class T, int N>

void G3D::SmallArray< T, N >::clear ( bool  shrinkIfNecessary = true )

inline

 {
 resize(0, shrinkIfNecessary);
 }

Here is the caller graph for this function:

template<class T, int N>

void G3D::SmallArray< T, N >::clearAndSetMemoryManager ( MemoryManager::Ref &  m )

inline

 {
 clear();
 m_rest.clearAndSetMemoryManager(m);
 }

Here is the caller graph for this function:

template<class T, int N>

bool G3D::SmallArray< T, N >::contains ( const T &  value ) const

inline

 {
 for (int i = std::min(m_size, N) - 1; i >= 0; --i) {
 if (m_embedded[i] == value) {
 return true;
 }
 }
 return m_rest.contains(value);
 }

Here is the caller graph for this function:

template<class T, int N>

void G3D::SmallArray< T, N >::fastRemove ( int  i, bool  shrinkIfNecessary = false  )

inline

 {
 debugAssert(i < m_size && i >= 0);
 if (i < N) {
 if (m_size <= N) {
 // Exclusively embedded
 m_embedded[i] = m_embedded[m_size - 1];
 } else {
 // Move one down from the rest array
 m_embedded[i] = m_rest.pop();
 }
 } else {
 // Removing from the rest array
 m_rest.fastRemove(i - N, shrinkIfNecessary);
 }
 --m_size;
 }

Here is the caller graph for this function:

template<class T, int N>

int G3D::SmallArray< T, N >::findIndex ( const T &  v )

inline

Find the index of v or -1 if not found

 {
 for (int i = 0; i < N; ++i) {
 if (m_embedded[i] == v) {
 return i;
 }
 }

 return m_rest.findIndex(v) + N;
 }

template<class T, int N>

const T& G3D::SmallArray< T, N >::last ( ) const

inline

 {
 return (*this)[size() - 1];
 }

template<class T, int N>

T& G3D::SmallArray< T, N >::last ( )

inline

 {
 return (*this)[size() - 1];
 }

template<class T, int N>

T& G3D::SmallArray< T, N >::next ( )

inline

 {
 ++m_size;
 if (m_size <= N) {
 return m_embedded[m_size - 1];
 } else {
 return m_rest.next();
 }
 }

Here is the caller graph for this function:

template<class T, int N>

template<int MIN_ELEMENTS>

SmallArray<T, N>& G3D::SmallArray< T, N >::operator= ( const Array< T, MIN_ELEMENTS > &  src )

inline

 {
 resize(src.size());
 for (int i = 0; i < src.size(); ++i) {
 (*this)[i] = src[i];
 }
 return *this;
 }

template<class T, int N>

T& G3D::SmallArray< T, N >::operator[] ( int  i )

inline

 {
 debugAssert(i < m_size && i >= 0);
 if (i < N) {
 return m_embedded[i];
 } else {
 return m_rest[i - N];
 }
 }

template<class T, int N>

const T& G3D::SmallArray< T, N >::operator[] ( int  i ) const

inline

 {
 debugAssert(i < m_size && i >= 0);
 if (i < N) {
 return m_embedded[i];
 } else {
 return m_rest[i - N];
 }
 }

template<class T, int N>

T G3D::SmallArray< T, N >::pop ( )

inline

 {
 debugAssert(m_size > 0);
 if (m_size <= N) {
 // Popping from embedded, don't need a temporary
 --m_size;
 return m_embedded[m_size];
 } else {
 // Popping from rest
 --m_size;
 return m_rest.pop();
 }
 }

Here is the caller graph for this function:

template<class T, int N>

void G3D::SmallArray< T, N >::popDiscard ( )

inline

 {
 debugAssert(m_size > 0);
 if (m_size > N) {
 m_rest.popDiscard();
 }
 --m_size;
 }

template<class T, int N>

void G3D::SmallArray< T, N >::push ( const T &  v )

inline

 {
 ++m_size;
 if (m_size <= N) {
 m_embedded[m_size - 1] = v;
 } else {
 m_rest.append(v);
 }
 }

Here is the caller graph for this function:

template<class T, int N>

void G3D::SmallArray< T, N >::resize ( int  n, bool  shrinkIfNecessary = true  )

inline

 {
 m_rest.resize(std::max(0, n - N), shrinkIfNecessary);
 m_size = n;
 }

Here is the caller graph for this function:

template<class T, int N>

int G3D::SmallArray< T, N >::size ( ) const

inline

 {
 return m_size;
 }

Here is the caller graph for this function:

Member Data Documentation

template<class T, int N>

T G3D::SmallArray< T, N >::m_embedded[N]

private

First N elements

template<class T, int N>

Array<T> G3D::SmallArray< T, N >::m_rest

private

Remaining elements

template<class T, int N>

int G3D::SmallArray< T, N >::m_size

private

---

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

• dep/g3dlite/include/G3D/SmallArray.h