/*---------------------------------------------------------------------------
                      D Y N A M I C  A R R A Y
                      
   Implementation file for a dynamically resizing array of void pointers.
   
   Mark Koennecke, September 1997
                    
   copyright: see copyright.h
   
-----------------------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include "fortify.h"
#include "sdynar.h"
#include "sdynar.i"

/*---------------------------------------------------------------------------*/
   pDynar CreateDynar(int iStart, int iEnd, int iGrain, 
                      void (*DataFree)(void *pData))
   {
     pDynar pNew = NULL;
     int iSize;
     
     pNew = (pDynar)malloc(sizeof(Dynar));
     if(!pNew)
     {
       return NULL;
     }
     memset(pNew, 0, sizeof(Dynar));
     
     pNew->iStart = iStart;
     pNew->iEnd   = iEnd;
     pNew->iGrain = iGrain;
     pNew->DataFree = DataFree;
     iSize = iEnd - iStart;
     assert(iSize > 0);
     pNew->pArray = (void **)malloc(iSize * sizeof(void *));
     if(!pNew->pArray)
     {
       free(pNew);
       return NULL;
     }
     memset(pNew->pArray,0,iSize * sizeof(void *));
     return pNew;
   }             
/*----------------------------------------------------------------------------*/
   void DeleteDynar(pDynar self)
   {
     int i, iSize;
     
     assert(self);
     
     iSize = self->iEnd - self->iStart;
     for(i = 0; i < iSize; i++)
     {
       if(self->pArray[i])
       {
         if(self->DataFree)
         {
           self->DataFree(self->pArray[i]);
         }
       }
     }
     free(self->pArray);
     free(self);
   }
/*---------------------------------------------------------------------------*/
  static int DynarResize(pDynar self, int iRequest)
  {
     void **pNew = NULL;
     int i, iNewStart, iNewEnd, iOldSize, iNewSize, iOffset;

     assert(self);
     iOldSize = self->iEnd - self->iStart;
     
     iNewStart = self->iStart;
     iNewEnd = self->iEnd;
     if(iRequest <= self->iStart)
     {
       iNewStart -= self->iGrain;
     }
     if(iRequest >= (self->iEnd - 1))
     {
       iNewEnd += self->iGrain;
     }
     iNewSize = iNewEnd - iNewStart;
     
     pNew = (void **)malloc(iNewSize * sizeof(void *));
     if(!pNew)
     {
       return 0;
     }
     memset(pNew,0,iNewSize*sizeof(void *));
     
     iOffset = self->iStart - iNewStart;
     if(iOffset < 0)
     {
       iOffset = - iOffset;
     }
     for(i = 0; i < iOldSize; i++)
     {
        pNew[i+iOffset] = self->pArray[i];
     }
     self->iStart = iNewStart;
     self->iEnd = iNewEnd;
     free(self->pArray);
     self->pArray = pNew;
     return 1;
  }                                   
/*----------------------------------------------------------------------------*/  
  int DynarPut(pDynar self, int iIndex, void *pData)
  {
     int iReal, iRet;
     
     assert(self);
     
     if( (iIndex < self->iStart) ||  (iIndex > self->iEnd -1) )
     {
       iRet = DynarResize(self,iIndex);
       if(!iRet)
       {
         return 0;
       }
     }
     
     iReal = iIndex - self->iStart;
     if(self->pArray[iReal])
     {
       if(self->DataFree)
       {
         self->DataFree(self->pArray[iReal]);
       }
     }
     self->pArray[iReal] = pData;
     return 1; 
  }
/*-------------------------------------------------------------------------*/
  int DynarPutCopy(pDynar self, int iIndex, void *pBuffer, int iDataLen)
  {
    char *pPtr = NULL;
    
    pPtr = (char *)malloc(iDataLen);
    if(!pPtr)
    {
      return 0;
    }
    memcpy(pPtr,pBuffer,iDataLen);
    return DynarPut(self,iIndex,pPtr);
  }  
/*--------------------------------------------------------------------------*/
  int DynarReplace(pDynar self, int iIndex, void *pData, int iDataLen)
  {
     int iReal, iRet;
     
     assert(self);

     if( (iIndex < self->iStart) ||  (iIndex >= self->iEnd -1) )
     {
       iRet = DynarResize(self,iIndex);
       if(!iRet)
       {
         return 0;
       }
     }

     iReal = iIndex - self->iStart;
     if(self->pArray[iReal])
     {
        memcpy(self->pArray[iReal],pData,iDataLen);
        return 1;
     }
     else
     {
       return DynarPutCopy(self,iIndex,pData,iDataLen);
     }
  }
/*---------------------------------------------------------------------------*/  
  int DynarGet(pDynar self, int iIndex, void **pData)
  {
     int iReal;
     
     assert(self);
     
     iReal = iIndex - self->iStart;
     *pData = self->pArray[iReal];
     return 1; 
  }
/*-------------------------------------------------------------------------*/
  int DynarGetCopy(pDynar self, int iIndex, void *pData, int iDataLen)
  {
     int iReal;
     
     assert(self);
     
     iReal = iIndex - self->iStart;
     memcpy(pData,self->pArray[iReal],iDataLen);
     return 1; 
  }