csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > Class Template Reference (Crystal Space 2.0 Public API Reference)

| ## Public API Reference

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

- Class List
- Class Index
- Class Hierarchy
- Class Members

Classes | Public Member Functions | Static Public Member Functions | Protected Member Functions
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > Class Template Reference
Containers

A templated array class. More...

`#include <csutil/array.h>`

Inheritance diagram for csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >:

List of all members.

## Classes
class | ConstIterator
| Iterator for the csArray class. More...
class | Iterator
| Iterator for the csArray class. More...
class | ReverseConstIterator
| Reverse iterator for the csArray class. More...
class | ReverseIterator
| Reverse iterator for the csArray class. More...
## Public Member Functions
size_t | Capacity () const
| Query vector capacity. Note that you should rarely need to do this.
size_t | Contains (T const &which) const
| An alias for Find() which may be considered more idiomatic by some.
| csArray (size_t in_capacity=0, const CapacityHandler &ch=CapacityHandler())
| Initialize object to have initial capacity of `in_capacity` elements.
| csArray (size_t in_capacity, const MemoryAllocator &alloc, const CapacityHandler &ch)
| Initialize object to have initial capacity of `in_capacity` elements and with specific memory allocator and capacity handler initializations.
| csArray (const csArray &source)
| Copy constructor.
bool | Delete (T const &item)
| Delete the given element from the array.
void | DeleteAll ()
| Clear the entire array, releasing all allocated memory.
bool | DeleteIndex (size_t n)
| Delete an element from the array.
bool | DeleteIndexFast (size_t n)
| Delete an element from the array in constant-time, regardless of the array's size.
bool | DeleteRange (size_t start, size_t end)
| Delete a given range (inclusive).
void | Empty ()
| Remove all elements.
size_t | Find (T const &which) const
| Find an element in this array.
template<class K >
size_t | FindKey (csArrayCmp< T, K > comparekey) const
| Find an element based upon some arbitrary key, which may be embedded within an element, or otherwise derived from it.
template<class K >
size_t | FindSortedKey (csArrayCmp< T, K > comparekey, size_t *candidate=0) const
| Find an element based on some key, using a comparison function.
T & | Get (size_t n)
| Get an element (non-const).
T const & | Get (size_t n) const
| Get an element (const).
const MemoryAllocator & | GetAllocator () const
| Return a reference to the allocator of this array.
T & | GetExtend (size_t n)
| Get an item from the array.
T & | GetExtend (size_t n, T const &what)
| Get an item from the array.
size_t | GetIndex (const T *which) const
| Given a pointer to an element in the array this function will return the index.
Iterator | GetIterator ()
| Return an Iterator which traverses the array.
ConstIterator | GetIterator () const
| Return an Iterator which traverses the array.
ReverseIterator | GetReverseIterator ()
| Return an ReverseIterator which traverses the array in reverse direction.
ReverseConstIterator | GetReverseIterator () const
| Return an Iterator which traverses the array.
size_t | GetSize () const
| Return the number of elements in the array.
bool | Insert (size_t n, T const &item)
| Insert element `item` before element `n`.
size_t | InsertSorted (const T &item, int(*compare)(T const &, T const &)=DefaultCompare, size_t *equal_index=0)
| Insert an element at a sorted position, using an element comparison function.
bool | IsEmpty () const
| Return whether the array is empty or not.
void | Merge (const csArray &origin)
| Push the elements of an array onto the tail end of the array.
void | MergeSmart (const csArray &origin)
| Push the elements of an array onto the tail end of the array if its elements aren't already present.
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > & | operator= (const csArray &other)
| Assignment operator.
bool | operator== (const csArray &other) const
| Check if this array has the exact same contents as other.
T & | operator[] (size_t n)
| Get an element (non-const).
T const & | operator[] (size_t n) const
| Get a const reference.
T | Pop ()
| Pop an element from tail end of array.
size_t | Push (T const &what)
| Push a copy of an element onto the tail end of the array.
size_t | PushSmart (T const &what)
| Push a element onto the tail end of the array if not already present.
void | Put (size_t n, T const &what)
| Insert or reset a copy of the element `what` at the position with index `n`.
csArray< T > | Section (size_t low, size_t high) const
| Get the portion of the array between `low` and `high` inclusive.
void | SetCapacity (size_t n)
| Set vector capacity to approximately `n` elements.
void | SetMinimalCapacity (size_t n)
| Set vector capacity to at least `n` elements.
void | SetSize (size_t n, T const &what)
| Set the actual number of items in this array.
void | SetSize (size_t n)
| Set the actual number of items in this array.
void | ShrinkBestFit ()
| Make the array just as big as it needs to be.
void | Sort (int(*compare)(T const &, T const &)=DefaultCompare)
| Sort array using a comparison function.
template<typename Pred >
void | Sort (Pred &pred)
| Sort array using a binary predicate.
template<typename Pred >
void | SortStable (Pred &pred)
| Sort array using a binary predicate and a stable sorting algorithm.
T const & | Top () const
| Return the top element but do not remove it. (const)
T & | Top ()
| Return the top element but do not remove it. (non-const)
void | TransferTo (csArray &destination)
| Transfer the entire contents of one array to the other.
void | Truncate (size_t n)
| Truncate the array to the specified number of elements.
| ~csArray ()
| Destroy array and all contained elements.
## Static Public Member Functions
static int | DefaultCompare (T const &r1, T const &r2)
| Compare two objects of the same type.
## Protected Member Functions
void | InitRegion (size_t start, size_t count)
| Initialize a region.
void | SetCapacityVeryUnsafe (size_t n)
| Set the internal array capacity.
void | SetDataVeryUnsafe (T *data)
| Set the internal pointer to the data.
void | SetSizeVeryUnsafe (size_t n)
| Set the internal array size.

## Detailed Description

### template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>
class csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >

A templated array class.

The objects in this class are constructed via copy-constructor and are destroyed when they are removed from the array or the array is destroyed.

Note:
  If you want to store reference-counted object pointers, such as iFoo*, then you should consider csRefArray, which is more idiomatic than csArray<csRef<iFoo> >.

Definition at line 421 of file array.h.

## Constructor & Destructor Documentation

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::csArray | ( | size_t | in_capacity = `0`,
|  | const CapacityHandler & | ch = `CapacityHandler()`
| ) |  | `[inline]`

Initialize object to have initial capacity of `in_capacity` elements.

The storage increase depends on the specified capacity handler. The default capacity handler accepts a threshold parameter by which the storage is increased each time the upper bound is exceeded.

Definition at line 549 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::csArray | ( | size_t | in_capacity,
|  | const MemoryAllocator & | alloc,
|  | const CapacityHandler & | ch
| ) |  | `[inline]`

Initialize object to have initial capacity of `in_capacity` elements and with specific memory allocator and capacity handler initializations.

Definition at line 569 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::~csArray | ( |  | ) | `[inline]`

Destroy array and all contained elements.

Definition at line 588 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::csArray | ( | const csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > & | source | ) | `[inline]`

Copy constructor.

Definition at line 594 of file array.h.

## Member Function Documentation

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Capacity | ( |  | ) | const`[inline]`

Query vector capacity. Note that you should rarely need to do this.

Definition at line 621 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Contains | ( | T const & | which | ) | const`[inline]`

An alias for Find() which may be considered more idiomatic by some.

Definition at line 964 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

static int csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::DefaultCompare | ( | T const & | r1,
|  | T const & | r2
| ) |  | `[inline, static]`

Compare two objects of the same type.

Parameters:

  r1 | Reference to first object.
  r2 | Reference to second object.

Returns:
  Zero if the objects are equal; less-than-zero if the first object is less than the second; or greater-than-zero if the first object is greater than the second.

Remarks:
  Assumes the existence of T::operator<(T). This is the default comparison function used by csArray for sorting if the client does not provide a custom function.

Definition at line 538 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

bool csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Delete | ( | T const & | item | ) | `[inline]`

Delete the given element from the array.

Returns:
  True if the item has been found and deleted, false otherwise.

Remarks:
  Performs a linear search of the array to locate `item`, thus it may be slow for large arrays.

Definition at line 1192 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::DeleteAll | ( |  | ) | `[inline]`

Clear the entire array, releasing all allocated memory.

See also:
  Empty()

Definition at line 1011 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

bool csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::DeleteIndex | ( | size_t | n | ) | `[inline]`

Delete an element from the array.

Returns:
  True if the indicated item index was valid, false otherwise.

Remarks:
  Deletion speed is proportional to the size of the array and the location of the element being deleted. If the order of the elements in the array is not important, then you can instead use DeleteIndexFast() for constant-time deletion.

Definition at line 1119 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

bool csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::DeleteIndexFast | ( | size_t | n | ) | `[inline]`

Delete an element from the array in constant-time, regardless of the array's size.

Returns:
  True if the indicated item index was valid, false otherwise.

Remarks:
  This is a special version of DeleteIndex() which does not preserve the order of the remaining elements. This characteristic allows deletions to be performed in constant-time, regardless of the size of the array.

Definition at line 1144 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

bool csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::DeleteRange | ( | size_t | start,
|  | size_t | end
| ) |  | `[inline]`

Delete a given range (inclusive).

Remarks:
  Will clamp `start` and `end` to the array limits.

Returns:
  false in case the inputs were invalid (csArrayItemNotFound) or if the start is greater then the number of items in the array.

Definition at line 1166 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Empty | ( |  | ) | `[inline]`

Remove all elements.

Similar to DeleteAll(), but does not release memory used by the array itself, thus making it more efficient for cases when the number of contained elements will fluctuate.

Definition at line 1051 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Find | ( | T const & | which | ) | const`[inline]`

Find an element in this array.

Returns:
  csArrayItemNotFound if not found, else the item index.

Warning:
  Performs a slow linear search. For faster searching, sort the array and then use FindSortedKey().

Definition at line 955 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>
template<class K >

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::FindKey | ( | csArrayCmp< T, K > | comparekey | ) | const`[inline]`

Find an element based upon some arbitrary key, which may be embedded within an element, or otherwise derived from it.

The incoming key functor defines the relationship between the key and the array's element type.

Returns:
  csArrayItemNotFound if not found, else item index.

Definition at line 762 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>
template<class K >

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::FindSortedKey | ( | csArrayCmp< T, K > | comparekey,
|  | size_t * | candidate = `0`
| ) |  | const`[inline]`

Find an element based on some key, using a comparison function.

Returns:
  csArrayItemNotFound if not found, else the item index.

Remarks:
  The array must be sorted.

Definition at line 887 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Get | ( | size_t | n | ) | `[inline]`

Get an element (non-const).

Definition at line 693 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T const& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Get | ( | size_t | n | ) | const`[inline]`

Get an element (const).

Definition at line 700 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

const MemoryAllocator& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetAllocator | ( |  | ) | const`[inline]`

Return a reference to the allocator of this array.

Definition at line 1365 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetExtend | ( | size_t | n | ) | `[inline]`

Get an item from the array.

If the number of elements in this array is too small the array will be automatically extended, and the newly added objects will be created using their default (no-argument) constructor.

Definition at line 711 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetExtend | ( | size_t | n,
|  | T const & | what
| ) |  | `[inline]`

Get an item from the array.

If the number of elements in this array is too small the array will be automatically extended, and the newly added objects will be constructed based on the given item what.

Definition at line 723 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetIndex | ( | const T * | which | ) | const`[inline]`

Given a pointer to an element in the array this function will return the index.

Note that this function does not check if the returned index is actually valid. The caller of this function is responsible for testing if the returned index is within the bounds of the array.

Definition at line 973 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

Iterator csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetIterator | ( |  | ) | `[inline]`

Return an Iterator which traverses the array.

Definition at line 1337 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

ConstIterator csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetIterator | ( |  | ) | const`[inline]`

Return an Iterator which traverses the array.

Definition at line 1341 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

ReverseIterator csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetReverseIterator | ( |  | ) | `[inline]`

Return an ReverseIterator which traverses the array in reverse direction.

Definition at line 1345 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

ReverseConstIterator csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetReverseIterator | ( |  | ) | const`[inline]`

Return an Iterator which traverses the array.

Definition at line 1349 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::GetSize | ( |  | ) | const`[inline]`

Return the number of elements in the array.

Definition at line 615 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::InitRegion | ( | size_t | start,
|  | size_t | count
| ) |  | `[inline, protected]`

Initialize a region.

This is a dangerous function to use because it does not properly destruct the items in the array.

Definition at line 457 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

bool csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Insert | ( | size_t | n,
|  | T const & | item
| ) |  | `[inline]`

Insert element `item` before element `n`.

Definition at line 855 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::InsertSorted | ( | const T & | item,
|  | int(*)(T const &, T const &) | compare = `DefaultCompare`,
|  | size_t * | equal_index = `0`
| ) |  | `[inline]`

Insert an element at a sorted position, using an element comparison function.

Parameters:

  item | The item to insert.
  compare | [optional] Pointer to a function to compare two elements.
  equal_index | [optional] Returns the index of an element equal to the one to be inserted, if one is found. csArrayItemNotFound otherwise.

Returns:
  The index of the inserted item.

Remarks:
  The array must be sorted.

Definition at line 921 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

bool csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::IsEmpty | ( |  | ) | const`[inline]`

Return whether the array is empty or not.

Returns:
  True if the array is empty, false otherwise.

Remarks:
  Rigidly equivalent to `return GetSize() == 0`, but more idiomatic.

Definition at line 1062 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Merge | ( | const csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > & | origin | ) | `[inline]`

Push the elements of an array onto the tail end of the array.

Parameters:

  origin | The array to push at the end of this array.

Definition at line 812 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::MergeSmart | ( | const csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > & | origin | ) | `[inline]`

Push the elements of an array onto the tail end of the array if its elements aren't already present.

If an element is found duplicate it's skipped.

Parameters:

  origin | The array to push at the end of this array.

Definition at line 824 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

csArray<T,ElementHandler,MemoryAllocator,CapacityHandler>& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::operator= | ( | const csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > & | other | ) | `[inline]`

Assignment operator.

Definition at line 603 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

bool csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::operator== | ( | const csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > & | other | ) | const`[inline]`

Check if this array has the exact same contents as other.

Definition at line 1353 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::operator[] | ( | size_t | n | ) | `[inline]`

Get an element (non-const).

Definition at line 731 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T const& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::operator[] | ( | size_t | n | ) | const`[inline]`

Get a const reference.

Definition at line 737 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Pop | ( |  | ) | `[inline]`

Pop an element from tail end of array.

Reimplemented in CS::Utility::StringArray< Allocator, CapacityHandler >, CS::Utility::StringArray< CS::Memory::AllocatorMalloc, csArrayCapacityDefault >, csPDelArray< T, MemoryAllocator, CapacityHandler >, csPDelArray< Target >, csPDelArray< renderMeshListInfo >, csPDelArray< csPluginLoadRec >, csPDelArray< csPixmap >, csPDelArray< Layer >, csPDelArray< ArchiveEntry, CS::Container::ArrayAllocDefault, csArrayCapacityFixedGrow< 256 > >, csPDelArray< csCommandLineOption >, csPDelArray< csPluginOption, CS::Container::ArrayAllocDefault, csArrayCapacityFixedGrow< 16 > >, csRefArray< T, Allocator, CapacityHandler >, csRefArray< iImage >, csRefArray< csShaderVariable >, csRefArray< iEventHandler >, csRefArray< CS::Animation::iSkeletonAnimNodeFactory >, csRefArray< iSndSysStreamCallback >, csRefArray< View2RenderView >, csRefArray< iObjectNameChangeListener >, csRefArray< iConfigListener >, csRefArray< iTextureHandle >, csRefArray< iObjectModelListener >, csRefArray< RViewPortal2RenderView >, csRefArray< SuperFrustum >, csRefArray< csVisibilityObjectWrapper >, csRefArray< Thread >, and csRefArray< iConfigFile >.

Definition at line 831 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Push | ( | T const & | what | ) | `[inline]`

Push a copy of an element onto the tail end of the array.

Returns:
  Index of newly added element.

Definition at line 774 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

size_t csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::PushSmart | ( | T const & | what | ) | `[inline]`

Push a element onto the tail end of the array if not already present.

Returns:
  Index of newly pushed element or index of already present element.

Definition at line 801 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Put | ( | size_t | n,
|  | T const & | what
| ) |  | `[inline]`

Insert or reset a copy of the element `what` at the position with index `n`.

If the size of the array is smaller than `n` then it will be resized.

Definition at line 746 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

csArray<T> csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Section | ( | size_t | low,
|  | size_t | high
| ) |  | const`[inline]`

Get the portion of the array between `low` and `high` inclusive.

Definition at line 873 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::SetCapacity | ( | size_t | n | ) | `[inline]`

Set vector capacity to approximately `n` elements.

Remarks:
  Never sets the capacity to fewer than the current number of elements in the array. See Truncate() or SetSize() if you need to adjust the number of actual array elements.

Definition at line 1073 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::SetCapacityVeryUnsafe | ( | size_t | n | ) | `[inline, protected]`

Set the internal array capacity.

Warning:
  This is obviously dangerous.

Definition at line 476 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::SetDataVeryUnsafe | ( | T * | data | ) | `[inline, protected]`

Set the internal pointer to the data.

Warning:
  This is obviously dangerous.

Definition at line 466 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::SetMinimalCapacity | ( | size_t | n | ) | `[inline]`

Set vector capacity to at least `n` elements.

Remarks:
  Never sets the capacity to fewer than the current number of elements in the array. See Truncate() or SetSize() if you need to adjust the number of actual array elements. This function will also never shrink the current capacity.

Definition at line 1086 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::SetSize | ( | size_t | n,
|  | T const & | what
| ) |  | `[inline]`

Set the actual number of items in this array.

This can be used to shrink an array (like Truncate()) or to enlarge an array, in which case it will properly construct all new items based on the given item.

Parameters:

  n | New array length.
  what | Object used as template to construct each newly added object using the object's copy constructor when the array size is increased by this method.

Definition at line 655 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::SetSize | ( | size_t | n | ) | `[inline]`

Set the actual number of items in this array.

This can be used to shrink an array (like Truncate()) or to enlarge an array, in which case it will properly construct all new items using their default (zero-argument) constructor.

Parameters:

  n | New array length.

Reimplemented in csPDelArray< T, MemoryAllocator, CapacityHandler >, csPDelArray< Target >, csPDelArray< renderMeshListInfo >, csPDelArray< csPluginLoadRec >, csPDelArray< csPixmap >, csPDelArray< Layer >, csPDelArray< ArchiveEntry, CS::Container::ArrayAllocDefault, csArrayCapacityFixedGrow< 256 > >, csPDelArray< csCommandLineOption >, and csPDelArray< csPluginOption, CS::Container::ArrayAllocDefault, csArrayCapacityFixedGrow< 16 > >.

Definition at line 677 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::SetSizeVeryUnsafe | ( | size_t | n | ) | `[inline, protected]`

Set the internal array size.

Warning:
  This is obviously dangerous.

Definition at line 471 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ShrinkBestFit | ( |  | ) | `[inline]`

Make the array just as big as it needs to be.

This is useful in cases where you know the array is not going to be modified anymore in order to preserve memory.

Definition at line 1098 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Sort | ( | int(*)(T const &, T const &) | compare = `DefaultCompare` | ) | `[inline]`

Sort array using a comparison function.

Reimplemented in CS::Utility::StringArray< Allocator, CapacityHandler >, and CS::Utility::StringArray< CS::Memory::AllocatorMalloc, csArrayCapacityDefault >.

Definition at line 983 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>
template<typename Pred >

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Sort | ( | Pred & | pred | ) | `[inline]`

Sort array using a binary predicate.

Definition at line 993 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>
template<typename Pred >

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::SortStable | ( | Pred & | pred | ) | `[inline]`

Sort array using a binary predicate and a stable sorting algorithm.

Definition at line 1002 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T const& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Top | ( |  | ) | const`[inline]`

Return the top element but do not remove it. (const)

Definition at line 841 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

T& csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Top | ( |  | ) | `[inline]`

Return the top element but do not remove it. (non-const)

Definition at line 848 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::TransferTo | ( | csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > & | destination | ) | `[inline]`

Transfer the entire contents of one array to the other.

The end result will be that this array will be completely empty and the other array will have all items that originally were in this array. This operation is very efficient.

Definition at line 633 of file array.h.

template<class T, class ElementHandler = csArrayElementHandler<T>, class MemoryAllocator = CS::Container::ArrayAllocDefault, class CapacityHandler = CS::Container::ArrayCapacityDefault>

void csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Truncate | ( | size_t | n | ) | `[inline]`

Truncate the array to the specified number of elements.

The new number of elements cannot exceed the current number of elements.

Remarks:
  Does not reclaim memory used by the array itself, though the removed objects are destroyed. To reclaim the array's memory invoke ShrinkBestFit(), or DeleteAll() if you want to release all allocated resources.
  The more general-purpose SetSize() method can also enlarge the array.

Definition at line 1035 of file array.h.

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

- csutil/array.h