Serious-Engine/Sources/Engine/Templates/StaticStackArray.cpp
2016-03-11 18:20:51 -06:00

202 lines
5.1 KiB
C++

/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_STATICSTACKARRAY_CPP
#define SE_INCL_STATICSTACKARRAY_CPP
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include <Engine/Templates/StaticStackArray.h>
#include <Engine/Templates/StaticArray.cpp>
/*
* Default constructor.
*/
template<class Type>
inline CStaticStackArray<Type>::CStaticStackArray(void) : CStaticArray<Type>() {
sa_UsedCount=0;
sa_ctAllocationStep = 256;
}
/*
* Destructor.
*/
template<class Type>
inline CStaticStackArray<Type>::~CStaticStackArray(void) {
};
/* Destroy all objects, and reset the array to initial (empty) state. */
template<class Type>
inline void CStaticStackArray<Type>::Clear(void) {
if (CStaticArray<Type>::Count()!=0) Delete();
}
/*
* Set how many elements to allocate when stack overflows.
*/
template<class Type>
inline void CStaticStackArray<Type>::SetAllocationStep(INDEX ctStep)
{
ASSERT(ctStep>0);
sa_ctAllocationStep = ctStep;
};
/*
* Create a given number of objects.
*/
template<class Type>
inline void CStaticStackArray<Type>::New(INDEX iCount) {
CStaticArray<Type>::New(iCount);
sa_UsedCount = 0;
};
/*
* Destroy all objects.
*/
template<class Type>
inline void CStaticStackArray<Type>::Delete(void) {
CStaticArray<Type>::Delete();
sa_UsedCount = 0;
}
/*
* Add new object(s) on top of stack.
*/
template<class Type>
inline Type &CStaticStackArray<Type>::Push(void) {
sa_UsedCount++;
if (sa_UsedCount>CStaticArray<Type>::Count()) {
Expand(CStaticArray<Type>::Count()+sa_ctAllocationStep);
}
ASSERT(sa_UsedCount <= CStaticArray<Type>::Count());
return CStaticArray<Type>::operator[](sa_UsedCount-1);
}
template<class Type>
inline Type *CStaticStackArray<Type>::Push(INDEX ct) {
sa_UsedCount+=ct;
while(sa_UsedCount>CStaticArray<Type>::Count()) {
Expand(CStaticArray<Type>::Count()+sa_ctAllocationStep);
}
ASSERT(sa_UsedCount <= CStaticArray<Type>::Count());
return &CStaticArray<Type>::operator[](sa_UsedCount-ct);
}
/* Remove one object from top of stack and return it. */
template<class Type>
inline Type &CStaticStackArray<Type>::Pop(void)
{
ASSERT(sa_UsedCount>0);
sa_UsedCount--;
return CStaticArray<Type>::operator[](sa_UsedCount);
}
/*
* Remove objects higher than the given index from stack, but keep stack space.
*/
template<class Type>
inline void CStaticStackArray<Type>::PopUntil(INDEX iNewTop)
{
ASSERT(iNewTop < sa_UsedCount);
sa_UsedCount = iNewTop+1;
}
/*
* Remove all objects from stack, but keep stack space.
*/
template<class Type>
inline void CStaticStackArray<Type>::PopAll(void) {
sa_UsedCount = 0;
}
/*
* Random access operator.
*/
template<class Type>
inline Type &CStaticStackArray<Type>::operator[](INDEX i) {
ASSERT(this!=NULL);
ASSERT(i<sa_UsedCount); // check bounds
return CStaticArray<Type>::operator[](i);
}
template<class Type>
inline const Type &CStaticStackArray<Type>::operator[](INDEX i) const {
ASSERT(this!=NULL);
ASSERT(i<sa_UsedCount); // check bounds
return CStaticArray<Type>::operator[](i);
}
/*
* Get number of elements in array.
*/
template<class Type>
INDEX CStaticStackArray<Type>::Count(void) const {
ASSERT(this!=NULL);
return sa_UsedCount;
}
/*
* Get index of a member from it's pointer
*/
template<class Type>
INDEX CStaticStackArray<Type>::Index(Type *ptMember) {
ASSERT(this!=NULL);
INDEX i = CStaticArray<Type>::Index(ptMember);
ASSERTMSG(i<sa_UsedCount, "CStaticStackArray<>::Index(): Not a member of this array!");
return i;
}
/*
* Assignment operator.
*/
template<class Type>
CStaticStackArray<Type> &CStaticStackArray<Type>::operator=(const CStaticStackArray<Type> &arOriginal)
{
ASSERT(this!=NULL);
ASSERT(&arOriginal!=NULL);
ASSERT(this!=&arOriginal);
// copy stack arrays
CStaticArray<Type>::operator=(arOriginal);
// copy used count
sa_UsedCount = arOriginal.sa_UsedCount;
return *this;
}
/* Move all elements of another array into this one. */
template<class Type>
void CStaticStackArray<Type>::MoveArray(CStaticStackArray<Type> &arOther)
{
ASSERT(this!=NULL);
ASSERT(&arOther!=NULL);
ASSERT(this!=&arOther);
// clear previous contents
Clear();
// if the other array has no elements
if (arOther.Count()==0) {
// no assignment
return;
}
// move data from the other array into this one and clear the other one
CStaticArray<Type>::MoveArray(arOther);
sa_UsedCount = arOther.sa_UsedCount ;
sa_ctAllocationStep = arOther.sa_ctAllocationStep ;
arOther.sa_UsedCount = 0;
}
#endif /* include-once check. */