#include <opennurbs_array.h>

Public Member Functions
	ON_SimpleArray () ON_NOEXCEPT
	construction //////////////////////////////////////////////////////// More...

	ON_SimpleArray (const ON_SimpleArray< T > &)
	Copy constructor. More...

	ON_SimpleArray (size_t)
	size_t parameter = initial capacity More...

	ON_SimpleArray (size_t, T)
	create an array of given size and initialize all items to the given value More...

virtual	~ON_SimpleArray ()

void	Append (const T &)

void	Append (int, const T *)
	Append copy of an array T[count]. More...

T &	AppendNew ()
	array operations //////////////////////////////////////////////////// More...

T *	Array ()
	The Array() function return the. More...

const T *	Array () const
	m_a pointer value. More...

T *	At (int)
	At(index) returns nullptr if index < 0 or index >= count. More...

const T *	At (int) const

T *	At (ON__INT64)

const T *	At (ON__INT64) const

T *	At (ON__UINT64)

const T *	At (ON__UINT64) const

T *	At (unsigned int)

const T *	At (unsigned int) const

T *	begin ()
	Support STL iterators and algorithms. More...

T const *	begin () const

int	BinarySearch (const T , int(compar)(const T , const T )) const
	See Also: ON_CompareIncreasing<T> and ON_CompareDecreasing<T> More...

int	BinarySearch (const T , int(compar)(const T , const T ), int) const

const T *	BinarySearchPtr (const T , int(compar)(const T , const T )) const

const T *	BinarySearchPtr (const T , int(compar)(const T , const T ), int) const

int	Capacity () const
	capacity of array More...

T const *	cbegin () const

T const *	cend () const

int	Count () const
	query /////////////////////////////////////////////////////////////// More...

ON__UINT32	DataCRC (ON__UINT32 current_remainder) const

void	Destroy ()
	onfree any memory and set count and capacity to zero More...

void	EmergencyDestroy (void)
	emergency bailout /////////////////////////////////////////////////// More...

template<class... _Val>
void	Emplace (int i, _Val &&... val)

template<class... _Val>
void	Emplace (int, _Val &&...)
	create a new item and insert it More...

template<class... _Val>
void	EmplaceBack (_Val &&... val)

template<class... _Val>
void	EmplaceBack (_Val &&...)
	create a new item an append it More...

void	Empty ()
	Sets count to 0, leaves capacity untouched. More...

T *	end ()

T const *	end () const

T *	First ()

const T *	First () const
	returns nullptr if count = 0 More...

bool	HeapSort (int(compar)(const T , const T *))

void	Insert (int, const T &)

int	InsertInSortedList (const T &, int(compar)(const T , const T *))

int	InsertInSortedList (const T &, int(compar)(const T , const T *), int)

T *	KeepArray ()

T *	Last ()

const T *	Last () const
	returns nullptr if count = 0 More...

void	MemSet (unsigned char)

int	NewCapacity () const

	operator const T * () const

	operator T* ()
	The cast operators return a pointer. More...

bool	operator!= (const ON_SimpleArray< T > &other) const =delete

ON_SimpleArray< T > &	operator= (const ON_SimpleArray< T > &)

bool	operator== (const ON_SimpleArray< T > &other) const =delete

T &	operator[] (int)

const T &	operator[] (int) const

T &	operator[] (ON__INT64)

const T &	operator[] (ON__INT64) const

T &	operator[] (ON__UINT64)

const T &	operator[] (ON__UINT64) const

T &	operator[] (unsigned int)

const T &	operator[] (unsigned int) const

bool	Permute (const int *)

void	Prepend (int, const T *)
	Prepend copy of an array T[count]. More...

bool	QuickSort (int(compar)(const T , const T *))
	See Also: ON_CompareIncreasing<T> and ON_CompareDecreasing<T> More...

bool	QuickSortAndRemoveDuplicates (int(compar)(const T , const T *))
	See Also: ON_CompareIncreasing<T> and ON_CompareDecreasing<T> More...

virtual T *	Realloc (T *, int)
	low level memory management ////////////////////////////////////////// More...

void	Remove ()

virtual void	Remove (int)

void	RemoveIf (bool(*predicate)(const T &key))

void	RemoveValue (const T &)

T *	Reserve (size_t)
	memory management //////////////////////////////////////////////////// More...

void	Reverse ()
	reverse order More...

int	Search (const T &) const

int	Search (const T , int(compar)(const T , const T )) const
	See Also: ON_CompareIncreasing<T> and ON_CompareDecreasing<T> More...

void	SetArray (T *p)

void	SetArray (T *p, int count, int capacity)

T *	SetCapacity (size_t)

void	SetCount (int)
	low level memory management ////////////////////////////////////////// More...

void	SetRange (int from, int count, T)

void	Shrink ()
	remove unused capacity More...

unsigned int	SizeOfArray () const
	amount of memory in the m_a[] array More...

unsigned int	SizeOfElement () const
	amount of memory in an m_a[] array element More...

bool	Sort (ON::sort_algorithm sort_algorithm, int , int(compar)(const T , const T )) const

bool	Sort (ON::sort_algorithm sort_algorithm, int , int(compar)(const T , const T , void ), void ) const

bool	Sort (ON::sort_algorithm sort_algorithm, unsigned int , int(compar)(const T , const T )) const

bool	Sort (ON::sort_algorithm sort_algorithm, unsigned int , int(compar)(const T , const T , void ), void ) const

void	Swap (int, int)
	swap elements i and j More...

unsigned int	UnsignedCount () const

void	Zero ()

Protected Member Functions
void	Move (int, int, int)
	implementation ////////////////////////////////////////////////////// More...

Protected Attributes
T *	m_a
	pointer to array memory More...

int	m_capacity
	actual length of m_a[] More...

int	m_count
	0 <= m_count <= m_capacity More...

Detailed Description

template<class T>
class ON_SimpleArray< T >

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete openNURBS copyright information see http://www.opennurbs.org. The ON_SimpleArray<> template is more efficient than the ON_ClassArray<> template, but ON_SimpleArray<> should not be used for arrays of classes that require explicit construction, destruction, or copy operators.

Elements returned by AppendNew() are memset to zero.

By default, ON_SimpleArray<> uses onrealloc() to manage the dynamic array memory. If you want to use something besides onrealloc() to manage the array memory, then override ON_SimpleArray::Realloc().

Member Function Documentation

◆ Array()

template<class T >

const T* ON_SimpleArray< T >::Array ( ) const

m_a pointer value.

◆ begin()

template<class T >

T const* ON_SimpleArray< T >::begin ( ) const

◆ Emplace()

template<class T >

template<class... _Val>

void ON_SimpleArray< T >::Emplace	(	int	,
		_Val &&	...
	)

create a new item and insert it

◆ EmplaceBack()

template<class T >

template<class... _Val>

void ON_SimpleArray< T >::EmplaceBack ( _Val && ... )

create a new item an append it

◆ end()

template<class T >

T const* ON_SimpleArray< T >::end ( ) const

◆ First()

template<class T >

const T* ON_SimpleArray< T >::First ( ) const

returns nullptr if count = 0

◆ Last()

template<class T >

const T* ON_SimpleArray< T >::Last ( ) const

returns nullptr if count = 0

◆ operator!=()

template<class T >

bool ON_SimpleArray< T >::operator!= ( const ON_SimpleArray< T > & other ) const

delete

◆ operator==()

template<class T >

bool ON_SimpleArray< T >::operator== ( const ON_SimpleArray< T > & other ) const

delete

Deleted these two functions because the compiler was actually using pointer comparison on m_a. Adding implementations for these in Rhino 8 is cumbersome because of the template initialization stuff, so use ON_SimpleArray_IsEqual for now.

Member Data Documentation

◆ m_a

template<class T >

T* ON_SimpleArray< T >::m_a

protected

pointer to array memory

◆ m_capacity

template<class T >

int ON_SimpleArray< T >::m_capacity

protected

actual length of m_a[]

◆ m_count

template<class T >

int ON_SimpleArray< T >::m_count

protected

0 <= m_count <= m_capacity

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

template<class T> class ON_SimpleArray< T >

Member Function Documentation

◆ Array()

◆ begin()

◆ Emplace()

◆ EmplaceBack()

◆ end()

◆ First()

◆ Last()

◆ operator!=()

◆ operator==()

Member Data Documentation

◆ m_a

◆ m_capacity

◆ m_count

template<class T>
class ON_SimpleArray< T >