NSWFL_IntegerStack.Cpp

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  Copyright © NetworkDLS 2023, All rights reserved
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
// PARTICULAR PURPOSE.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _NSWFL_IntegerStack_CPP_
#define _NSWFL_IntegerStack_CPP_
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "NSWFL.H"

#ifdef _USE_GLOBAL_MEMPOOL
extern NSWFL::Memory::MemoryPool *pMem; //pMem must be defined and initalized elsewhere.
#endif

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace NSWFL {
	namespace Collections {
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::Push(int iNumber)
		{
			if (iFree == 0)
			{
				if (!this->bAutoGrow)
				{
					return false;
				}

				this->iStackSize += this->iInitialSize;
				this->iFree += this->iInitialSize;

				//No free stack space, need to allocate more.

				if ((iStack = (int *)realloc(iStack, (sizeof(int) * this->iStackSize))) == NULL)
				{
					return false;
				}
			}

			//Move all values down one position in the stack.
			for (unsigned int iPos = (iStackSize - iFree); iPos > 0; iPos--)
			{
				iStack[iPos] = iStack[iPos - 1];
			}

			iStack[0] = iNumber;

			iFree--;

			return true;
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		int IntegerStack::Pop(void)
		{
			if (iFree == this->iStackSize)
			{
				//The stack is empty space.
				return false;
			}

			return iStack[(iStackSize - iFree++) - 1];
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::Peek(unsigned int iSlot, int *iNumber)
		{
			if (iSlot >= (iStackSize - iFree))
			{
				//Invalid slot.
				return false;
			}

			if (iFree == this->iStackSize)
			{
				//The stack is empty.
				return false;
			}

			*iNumber = iStack[iSlot];

			return true;
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::Peek(int *iNumber)
		{
			if (iFree == this->iStackSize)
			{
				//The stack is empty.
				return false;
			}

			*iNumber = iStack[(iStackSize - iFree) - 1];

			return true;
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::Pop(int *iNumber)
		{
			if (iFree == this->iStackSize)
			{
				//The stack is empty.
				return false;
			}

			*iNumber = iStack[(iStackSize - iFree) - 1];

			iFree++;

			return true;
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		unsigned int IntegerStack::GetFreeSize(void)
		{
			return this->iFree;
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::IsStackEmpty(void)
		{
			return (this->iFree == this->iStackSize);
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		unsigned int IntegerStack::GetStackLevel(void)
		{
			return(this->iStackSize - this->iFree);
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		unsigned int IntegerStack::GetStackSize(void)
		{
			return this->iStackSize;
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::IsStackFull(void)
		{
			return(this->iFree == 0);
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::Initialize(void)
		{
			return this->Initialize(100, true);
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::Initialize(unsigned int iInitialSize)
		{
			return this->Initialize(iInitialSize, true);
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::Initialize(unsigned int iInitialSize, bool bAutoGrow)
		{
			if ((iStack = (int *)calloc(iInitialSize, sizeof(int))) == NULL)
			{
				return false;
			}

			this->iInitialSize = iInitialSize;
			this->iStackSize = iInitialSize;
			this->iFree = iInitialSize;
			this->bAutoGrow = bAutoGrow;

			return true;
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		bool IntegerStack::Destroy(void)
		{
			if (this->iStackSize > 0)
			{
				free(iStack);
			}
			return true;
		}
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		IntegerStack::IntegerStack()
		{
			this->Initialize();
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		IntegerStack::IntegerStack(unsigned int iInitialSize)
		{
			this->Initialize(iInitialSize);
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		IntegerStack::IntegerStack(unsigned int iInitialSize, bool bAutoGrow)
		{
			this->Initialize(iInitialSize, bAutoGrow);
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		IntegerStack::~IntegerStack()
		{
			this->Destroy();
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	} //namespace::InsecureInterface
} //namespace::NSWFL
#endif