The Diffraction Grating Calculator

#include "StdAfx.h"
#include "ObjectList.h"
#include "GenericObj.h"

CObjectList::CObjectList(UINT32 unInitAllocPtrIdx /* = MIN_ALLOC_SPACE */)
{
   unLastErrorCode = OLIST_ERRCODE_OK;
   pPtrArray = 0;
   unMaxAllocPtrIdx = 0;
   unPtrIdx = 0;
   unLastObjectIdx = 0;

   if(!unInitAllocPtrIdx)
      unInitAllocPtrIdx = MIN_ALLOC_SPACE;

   AllocateMemory(unInitAllocPtrIdx);
   if ( GetLastErrorCode() == OLIST_ERRCODE_OVERFLOW )
      throw;
}

CObjectList::~CObjectList()
{
   if(pPtrArray)
   {
      // now delete array object
      delete [] pPtrArray;
      pPtrArray = 0;
   }
}

void CObjectList::AllocateMemory(UINT32 unRequiredIdx)
{
   if(unRequiredIdx <= unMaxAllocPtrIdx)
      return;

   if(!pPtrArray)
   {
      pPtrArray = new POINTER[unRequiredIdx+MIN_ALLOC_SPACE];
      if(!pPtrArray)
         unLastErrorCode = OLIST_ERRCODE_NEWOBJALLOC;
      ZeroMemory(pPtrArray, sizeof(POINTER));
      unMaxAllocPtrIdx = unRequiredIdx+MIN_ALLOC_SPACE;
      return;
   }

   // re-alloc
   UINT32 unNewMaxAllocPtrIdx = unRequiredIdx + MIN_ALLOC_SPACE;
   if ( unNewMaxAllocPtrIdx >= UINT32_ERR ) // max size
      unNewMaxAllocPtrIdx = UINT32_ERR - MIN_ALLOC_SPACE + 1;
   if ( unRequiredIdx > unNewMaxAllocPtrIdx ) // overflow
   {
      unLastErrorCode = OLIST_ERRCODE_OVERFLOW;
      return;
   }
   POINTER *pNewPtrArray = new POINTER[unNewMaxAllocPtrIdx];
   if(!pNewPtrArray)
      unLastErrorCode = OLIST_ERRCODE_NEWOBJALLOC;
   ZeroMemory(pNewPtrArray, sizeof(POINTER) * unNewMaxAllocPtrIdx);

   // copy previous data
   MoveMemory((void*) pNewPtrArray, (void*) pPtrArray, sizeof(POINTER) * unMaxAllocPtrIdx);

   // delete original array
   delete [] pPtrArray;
   pPtrArray = pNewPtrArray;
   unMaxAllocPtrIdx = unNewMaxAllocPtrIdx;
}

UINT32 CObjectList::GetLastErrorCode(void)
{
   return unLastErrorCode;
}

UINT32 CObjectList::AddObject(POINTER pObject)
{
   AllocateMemory(unPtrIdx+1); // make sure we have enough room
   if ( GetLastErrorCode() == OLIST_ERRCODE_OVERFLOW )
      return UINT32_ERR;
   *(pPtrArray+unPtrIdx) = pObject;
   unLastObjectIdx = unPtrIdx;
   unPtrIdx++;
   return unPtrIdx;
}

UINT32 CObjectList::GetLastObjectIdx(void)
{
   return unLastObjectIdx;
}

UINT32 CObjectList::InsertObject(POINTER pObject, UINT32 unTargPtrIdx)
{
   AllocateMemory(unPtrIdx+1); // make sure we have enough room
   if ( GetLastErrorCode() == OLIST_ERRCODE_OVERFLOW )
      return UINT32_ERR;
   for(UINT32 unAuxPtrIdx = unPtrIdx-1 ; (unAuxPtrIdx < unPtrIdx) && (unAuxPtrIdx >= unTargPtrIdx) ; unAuxPtrIdx--)
      *(pPtrArray+unAuxPtrIdx+1) = *(pPtrArray+unAuxPtrIdx);
   *(pPtrArray+unTargPtrIdx) = pObject;
   unLastObjectIdx = unTargPtrIdx;
   unPtrIdx++;
   return unPtrIdx;
}

UINT32 CObjectList::FindObject(POINTER pObject)
{
   UINT32 unAuxPtrIdx;
   for(unAuxPtrIdx = 0 ; unAuxPtrIdx < unPtrIdx ; unAuxPtrIdx++)
   {
      if(*(pPtrArray+unAuxPtrIdx) == pObject)
         return unAuxPtrIdx;
   }
   return UINT32_ERR;
}

UINT32 CObjectList::DeleteObject(POINTER pObject)
{
   UINT32 unTargPtrIdx;
   unTargPtrIdx = FindObject((POINTER) pObject);
   if(unTargPtrIdx == UINT32_ERR)
      return UINT32_ERR;
   return DeleteObjectIdx(unTargPtrIdx);
}

UINT32 CObjectList::DeleteObjectIdx(UINT32 unTargPtrIdx)
{
   UINT32 unAuxPtrIdx;

   if(unTargPtrIdx >= unPtrIdx)
      unLastErrorCode = OLIST_ERRCODE_ERROBJIDX;

   for(unAuxPtrIdx = unTargPtrIdx ; unAuxPtrIdx < unPtrIdx-1 ; unAuxPtrIdx++)
      *(pPtrArray+unAuxPtrIdx) = *(pPtrArray+unAuxPtrIdx+1);

   unPtrIdx--;
   return unPtrIdx;
}

void CObjectList::SwapItems(UINT32 unIndex_A, UINT32 unIndex_B)
{
   POINTER pAuxPtrArray;
   if(unIndex_A >= unPtrIdx)
      unLastErrorCode = OLIST_ERRCODE_ERROBJIDX;
   if(unIndex_B >= unPtrIdx)
      unLastErrorCode = OLIST_ERRCODE_ERROBJIDX;
   pAuxPtrArray = *(pPtrArray+unIndex_A);
   *(pPtrArray+unIndex_A) = *(pPtrArray+unIndex_B);
   *(pPtrArray+unIndex_B) = pAuxPtrArray;
}

void CObjectList::EraseAllEntries(void)
{
   UINT32 unAuxPtrIdx;

   for(unAuxPtrIdx = 0 ; unAuxPtrIdx < unPtrIdx ; unAuxPtrIdx++)
      *(pPtrArray+unAuxPtrIdx) = 0;

   unPtrIdx = 0;
}

UINT32 CObjectList::GetObjectCount(void)
{
   return unPtrIdx;
}

// get binary size as byte buffers stripped of terminators
UINT32 CObjectList::GetBinStringTotalSize(void)
{
   UINT32 unBinSize  = 0;
   UINT32 unObjCount = GetObjectCount();
   TCHAR* pObj = NULL;

   for ( UINT32 unObj = 0; unObj < unObjCount; unObj++ )
   {
      pObj = NULL;
      pObj = (TCHAR*) GetObjectByIdx(unObj);
      if ( pObj )
      {
#if defined(UNICODE)
         unBinSize += (UINT32) 2 * (_tcslen(pObj));
#else
         unBinSize += (UINT32) _tcslen(pObj);
#endif
      }
   }
   return unBinSize;
}

// get binary size as unknown object
UINT32 CObjectList::GetBinTotalSize(void)
{
   UINT32 unBinSize  = 0;
   UINT32 unObjCount = GetObjectCount();
   POINTER pObj = NULL;

   for ( UINT32 unObj = 0; unObj < unObjCount; unObj++ )
   {
      pObj = NULL;
      pObj = GetObjectByIdx(unObj);
      if ( pObj )
      {
         unBinSize += sizeof(pObj);
      }
   }
   return unBinSize;
}

// get binary size as generic object
UINT32 CObjectList::GetBinGenericTotalSize(void)
{
   UINT32 unBinSize  = 0;
   UINT32 unObjCount = GetObjectCount();
   CGenericObj* pObj = NULL;

   for ( UINT32 unObj = 0; unObj < unObjCount; unObj++ )
   {
      pObj = NULL;
      pObj = (CGenericObj*) GetObjectByIdx(unObj);
      if ( pObj )
      {
         // TODO: see whatever we may need ...
         unBinSize += sizeof(pObj);
      }
   }
   return unBinSize;
}

POINTER CObjectList::GetCurObject(void)
{
   POINTER pObject;

   if(!unPtrIdx)
      return 0;

   pObject = *(pPtrArray+unPtrIdx-1);
   return pObject;
}

POINTER CObjectList::GetObjectByIdx(UINT32 unObjectIdx)
{
   POINTER pObject;

   if(unObjectIdx >= unPtrIdx)
      return NULL;

   pObject = *(pPtrArray+unObjectIdx);
   return pObject;
}