irrlicht/include/irrArray.h

514 lines
12 KiB
C++

// Copyright (C) 2002-2008 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine" and the "irrXML" project.
// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
#ifndef __IRR_ARRAY_H_INCLUDED__
#define __IRR_ARRAY_H_INCLUDED__
#include "irrTypes.h"
#include "heapsort.h"
#include "irrAllocator.h"
namespace irr
{
namespace core
{
//! Self reallocating template array (like stl vector) with additional features.
/** Some features are: Heap sorting, binary search methods, easier debugging.
*/
template <class T, typename TAlloc = irrAllocator<T> >
class array
{
public:
//! Default constructor for empty array.
array()
: data(0), allocated(0), used(0),
free_when_destroyed(true), is_sorted(true)
{
}
//! Constructs an array and allocates an initial chunk of memory.
/** \param start_count Amount of elements to pre-allocate. */
array(u32 start_count)
: data(0), allocated(0), used(0),
free_when_destroyed(true), is_sorted(true)
{
reallocate(start_count);
}
//! Copy constructor
array(const array<T>& other)
: data(0)
{
*this = other;
}
//! Destructor.
/** Frees allocated memory, if set_free_when_destroyed was not set to
false by the user before. */
~array()
{
if (free_when_destroyed)
{
for (u32 i=0; i<used; ++i)
allocator.destruct(&data[i]);
allocator.deallocate(data);
}
}
//! Reallocates the array, make it bigger or smaller.
/** \param new_size New size of array. */
void reallocate(u32 new_size)
{
T* old_data = data;
data = allocator.allocate(new_size); //new T[new_size];
allocated = new_size;
// copy old data
s32 end = used < new_size ? used : new_size;
for (s32 i=0; i<end; ++i)
{
// data[i] = old_data[i];
allocator.construct(&data[i], old_data[i]);
}
// destruct old data
for (u32 j=0; j<used; ++j)
allocator.destruct(&old_data[j]);
if (allocated < used)
used = allocated;
allocator.deallocate(old_data); //delete [] old_data;
}
//! Adds an element at back of array.
/** If the array is too small to add this new element it is made bigger.
\param element: Element to add at the back of the array. */
void push_back(const T& element)
{
if (used + 1 > allocated)
{
// reallocate(used * 2 +1);
// this doesn't work if the element is in the same array. So
// we'll copy the element first to be sure we'll get no data
// corruption
T e(element);
reallocate(used * 2 +1); // increase data block
allocator.construct(&data[used++], e); // data[used++] = e; // push_back
}
else
{
//data[used++] = element;
// instead of using this here, we copy it the safe way:
allocator.construct(&data[used++], element);
}
is_sorted = false;
}
//! Adds an element at the front of the array.
/** If the array is to small to add this new element, the array is
made bigger. Please note that this is slow, because the whole array
needs to be copied for this.
\param element Element to add at the back of the array. */
void push_front(const T& element)
{
insert(element);
}
//! Insert item into array at specified position.
/** Please use this only if you know what you are doing (possible
performance loss). The preferred method of adding elements should be
push_back().
\param element: Element to be inserted
\param index: Where position to insert the new element. */
void insert(const T& element, u32 index=0)
{
_IRR_DEBUG_BREAK_IF(index>used) // access violation
if (used + 1 > allocated)
reallocate(used +1);
for (u32 i=used; i>index; --i)
{
if (i<used)
allocator.destruct(&data[i]);
allocator.construct(&data[i], data[i-1]); // data[i] = data[i-1];
}
if (used > index)
allocator.destruct(&data[index]);
allocator.construct(&data[index], element); // data[index] = element;
is_sorted = false;
++used;
}
//! Clears the array and deletes all allocated memory.
void clear()
{
for (u32 i=0; i<used; ++i)
allocator.destruct(&data[i]);
allocator.deallocate(data); // delete [] data;
data = 0;
used = 0;
allocated = 0;
is_sorted = true;
}
//! Sets pointer to new array, using this as new workspace.
/** \param newPointer: Pointer to new array of elements.
\param size: Size of the new array. */
void set_pointer(T* newPointer, u32 size)
{
for (u32 i=0; i<used; ++i)
allocator.destruct(&data[i]);
allocator.deallocate(data); // delete [] data;
data = newPointer;
allocated = size;
used = size;
is_sorted = false;
}
//! Sets if the array should delete the memory it uses upon destruction.
/** \param f If true, the array frees the allocated memory in its
destructor, otherwise not. The default is true. */
void set_free_when_destroyed(bool f)
{
free_when_destroyed = f;
}
//! Sets the size of the array and allocates new elements if necessary.
/** Please note: This is only secure when using it with simple types,
because no default constructor will be called for the added elements.
\param usedNow Amount of elements now used. */
void set_used(u32 usedNow)
{
if (allocated < usedNow)
reallocate(usedNow);
used = usedNow;
}
//! Assignment operator
void operator=(const array<T>& other)
{
if (data)
{
for (u32 i=0; i<used; ++i)
allocator.destruct(&data[i]);
allocator.deallocate(data); // delete [] data;
}
//if (allocated < other.allocated)
if (other.allocated == 0)
data = 0;
else
data = allocator.allocate(other.allocated); // new T[other.allocated];
used = other.used;
free_when_destroyed = other.free_when_destroyed;
is_sorted = other.is_sorted;
allocated = other.allocated;
for (u32 i=0; i<other.used; ++i)
allocator.construct(&data[i], other.data[i]); // data[i] = other.data[i];
}
//! Equality operator
bool operator == (const array<T>& other) const
{
if (used != other.used)
return false;
for (u32 i=0; i<other.used; ++i)
if (data[i] != other[i])
return false;
return true;
}
//! Inequality operator
bool operator != (const array<T>& other) const
{
return !(*this==other);
}
//! Direct access operator
T& operator [](u32 index)
{
_IRR_DEBUG_BREAK_IF(index>=used) // access violation
return data[index];
}
//! Direct const access operator
const T& operator [](u32 index) const
{
_IRR_DEBUG_BREAK_IF(index>=used) // access violation
return data[index];
}
//! Gets last element.
T& getLast()
{
_IRR_DEBUG_BREAK_IF(!used) // access violation
return data[used-1];
}
//! Gets last element
const T& getLast() const
{
_IRR_DEBUG_BREAK_IF(!used) // access violation
return data[used-1];
}
//! Gets a pointer to the array.
/** \return Pointer to the array. */
T* pointer()
{
return data;
}
//! Gets a const pointer to the array.
/** \return Pointer to the array. */
const T* const_pointer() const
{
return data;
}
//! Get size of array.
/** \return Size of elements used in the array. */
u32 size() const
{
return used;
}
//! Get amount of memory allocated.
/** \return Amount of memory allocated. The amount of bytes
allocated would be allocated_size() * sizeof(ElementsUsed); */
u32 allocated_size() const
{
return allocated;
}
//! Check if array is empty.
/** \return True if the array is empty false if not. */
bool empty() const
{
return used == 0;
}
//! Sorts the array using heapsort.
/** There is no additional memory waste and the algorithm performs
O(n*log n) in worst case. */
void sort()
{
if (is_sorted || used<2)
return;
heapsort(data, used);
is_sorted = true;
}
//! Performs a binary search for an element, returns -1 if not found.
/** The array will be sorted before the binary search if it is not
already sorted.
\param element Element to search for.
\return Position of the searched element if it was found,
otherwise -1 is returned. */
s32 binary_search(const T& element)
{
sort();
return binary_search(element, 0, used-1);
}
//! Performs a binary search for an element, returns -1 if not found.
/** The array must be sorted prior
\param element Element to search for.
\return Position of the searched element if it was found, otherwise -1
is returned. */
s32 binary_search_const(const T& element) const
{
return binary_search(element, 0, used-1);
}
//! Performs a binary search for an element, returns -1 if not found.
/** \param element: Element to search for.
\param left First left index
\param right Last right index.
\return Position of the searched element if it was found, otherwise -1
is returned. */
s32 binary_search(const T& element, s32 left, s32 right) const
{
if (!used)
return -1;
s32 m;
do
{
m = (left+right)>>1;
if (element < data[m])
right = m - 1;
else
left = m + 1;
} while((element < data[m] || data[m] < element) && left<=right);
// this last line equals to:
// " while((element != array[m]) && left<=right);"
// but we only want to use the '<' operator.
// the same in next line, it is "(element == array[m])"
if (!(element < data[m]) && !(data[m] < element))
return m;
return -1;
}
//! Finds an element in linear time, which is very slow.
/** Use binary_search for faster finding. Only works if ==operator is
implemented.
\param element Element to search for.
\return Position of the searched element if it was found, otherwise -1
is returned. */
s32 linear_search(const T& element) const
{
for (u32 i=0; i<used; ++i)
if (element == data[i])
return (s32)i;
return -1;
}
//! Finds an element in linear time, which is very slow.
/** Use binary_search for faster finding. Only works if ==operator is
implemented.
\param element: Element to search for.
\return Position of the searched element if it was found, otherwise -1
is returned. */
s32 linear_reverse_search(const T& element) const
{
for (s32 i=used-1; i>=0; --i)
if (data[i] == element)
return i;
return -1;
}
//! Erases an element from the array.
/** May be slow, because all elements following after the erased
element have to be copied.
\param index: Index of element to be erased. */
void erase(u32 index)
{
_IRR_DEBUG_BREAK_IF(index>=used) // access violation
for (u32 i=index+1; i<used; ++i)
{
allocator.destruct(&data[i-1]);
allocator.construct(&data[i-1], data[i]); // data[i-1] = data[i];
}
allocator.destruct(&data[used-1]);
--used;
}
//! Erases some elements from the array.
/** May be slow, because all elements following after the erased
element have to be copied.
\param index: Index of the first element to be erased.
\param count: Amount of elements to be erased. */
void erase(u32 index, s32 count)
{
_IRR_DEBUG_BREAK_IF(index>=used || count<1 || index+count>used) // access violation
u32 i;
for (i=index; i<index+count; ++i)
allocator.destruct(&data[i]);
for (i=index+count; i<used; ++i)
{
if (i > index+count)
allocator.destruct(&data[i-count]);
allocator.construct(&data[i-count], data[i]); // data[i-count] = data[i];
if (i >= used-count)
allocator.destruct(&data[i]);
}
used-= count;
}
//! Sets if the array is sorted
void set_sorted(bool _is_sorted)
{
is_sorted = _is_sorted;
}
private:
T* data;
u32 allocated;
u32 used;
bool free_when_destroyed;
bool is_sorted;
TAlloc allocator;
};
} // end namespace core
} // end namespace irr
#endif