Vector.c

Go to the documentation of this file.

/*******************************************************************************
  APG Version 6.3
  Copyright (C) 2005 - 2012 Lowell D. Thomas, all rights reserved
 
  author:  Lowell D. Thomas
  email:   lowell@coasttocoastresearch.com
  website: http://www.coasttocoastresearch.com
 
  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.
 
  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, see
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>
  or write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*******************************************************************************/
#include "Apg.h"
#include "Private.h"
 
// VECTOR COMPONENT FUNCTIONS
 
// private vector instance context
typedef struct
{
  void* vpMemCtx;         // context to the underlying memory component
  char* cpData;           // pointer to the vector's data buffer
  apg_uint uiElementSize;    // number of bytes in one element
  apg_uint uiReserved;       // number of elements that have been reserved on the buffer
  apg_uint uiUsed;           // number of the reserved elements that have been used
  apg_uint uiReallocations;  // statistics - number buffer reallocations done
  void* vpValidate;       // must be equal to the struct address
} APG_VECTOR_CTX;
 
typedef struct
{
  apg_uint uiElementSize;
  apg_uint uiElements;
  apg_uint uiValidator;
} APG_VECTOR_EXPORT_HDR;
static apg_uint uiGrow(APG_VECTOR_CTX*   spCtx, apg_uint uiElements);
 
void* vpVecCtor(void* vpMemCtx, apg_uint uiElementSize, apg_uint uiInitialAlloc)
{
  void* vpReturn = NULL;
  APG_VECTOR_CTX* spCtx;
  while(APG_TRUE){
          if(!vpMemCtx){break;}
          if(!uiMemValidate(vpMemCtx)){break;}
            if(uiElementSize == 0){uiElementSize = APG_VEC_ELEMENT;}
            if(uiInitialAlloc == 0){uiInitialAlloc = APG_VEC_ALLOC;}
 
            // allocate the vector context
            spCtx = (APG_VECTOR_CTX*)vpMemAlloc(vpMemCtx, sizeof(APG_VECTOR_CTX));
            if(!spCtx){break;}
 
            // allocate the initial vector buffer
            memset((void*)spCtx, 0, sizeof(*spCtx));
            spCtx->vpMemCtx = vpMemCtx;
            spCtx->cpData = (char*)vpMemAlloc(vpMemCtx, uiElementSize * uiInitialAlloc);
            if(!spCtx->cpData)
            {
              // free the context and return failure
              vMemFree(vpMemCtx, (void*)spCtx);
              break;
            }
 
            // initialize the context
            spCtx->vpMemCtx = vpMemCtx;
            spCtx->uiElementSize = uiElementSize;
            spCtx->uiReserved = uiInitialAlloc;
 
            // success
            spCtx->vpValidate = (void*)spCtx;
            vpReturn = (void*)spCtx;
          break;
  }
  return vpReturn;
}
 
void  vVecDtor(void* vpCtx)
{
    APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  // no error and no action if vpCtx = NULL
  if(vpCtx && (spCtx->vpValidate == (void*)spCtx))
  {
    // delete the data buffer & context
    spCtx->vpValidate = NULL;
    vMemFree(spCtx->vpMemCtx, (void*)spCtx->cpData);
    vMemFree(spCtx->vpMemCtx, (void*)spCtx);
  }
  return;
}
 
apg_uint uiVecValidate(void* vpCtx){
        APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
        return (spCtx && spCtx->vpValidate == (void*)spCtx);
}
 
apg_uint uiVecBytes(void* vpCtx)
{
  apg_uint uiRet = 0;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          uiRet = spCtx->uiUsed * spCtx->uiElementSize;
  }
  return uiRet;
}
 
apg_uint uiVecSize(void* vpCtx)
{
  apg_uint uiRet = 0;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          uiRet = spCtx->uiUsed;
  }
  return uiRet;
}
 
apg_uint uiVecElementSize(void* vpCtx)
{
  apg_uint uiRet = 0;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          uiRet = spCtx->uiElementSize;
  }
  return uiRet;
}
 
apg_uint uiVecReallocations(void* vpCtx)
{
  apg_uint uiRet = 0;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          uiRet = spCtx->uiReallocations;
  }
  return uiRet;
}
 
void  vVecClear(void* vpCtx)
{
    APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(vpCtx && (spCtx->vpValidate == (void*)spCtx))
  {
    spCtx->uiUsed = 0;
  }
  return;
}
 
void* vpVecPush(void* vpCtx, void* vpElement)
{
  void*       vpReturn = NULL;
  apg_uint       uiTest = APG_TRUE;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  while(APG_TRUE){
          if(!(spCtx && spCtx->vpValidate == (void*)spCtx)){break;}
          if(spCtx->uiUsed >= spCtx->uiReserved)
          {
            uiTest = uiGrow(spCtx, 1);
            if(!uiTest){break;}
          }
 
          vpReturn = (void*)(spCtx->cpData + (spCtx->uiUsed * spCtx->uiElementSize));
          if(vpElement)
          {
            // copy new element to vector
            memcpy(vpReturn, vpElement, spCtx->uiElementSize);
          }
 
          // success, return a pointer to the new element
          ++spCtx->uiUsed;
          break;
  }
  return vpReturn;
}
 
void* vpVecPushn(void* vpCtx, void* vpElement, apg_uint uiCount)
{
  void*       vpReturn = NULL;
  apg_uint       uiTest = APG_TRUE;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  while(APG_TRUE){
          if(!(spCtx && spCtx->vpValidate == (void*)spCtx)){break;}
 
          if(uiCount)
          {
            // check allocation
            if((spCtx->uiUsed + uiCount) > spCtx->uiReserved)
            {
              uiTest = uiGrow(spCtx, uiCount);
              if(!uiTest){break;}
            }
 
            vpReturn = (void*)(spCtx->cpData + (spCtx->uiUsed * spCtx->uiElementSize));
            if(vpElement)
            {
              // copy new elements to vector
              memcpy(vpReturn, vpElement, uiCount * spCtx->uiElementSize);
            }
            spCtx->uiUsed += uiCount;
          }
          break;
  }
  return vpReturn;
}
 
void* vpVecPop(void* vpCtx)
{
  void*       vpReturn = NULL;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          if(spCtx->uiUsed)
          {
            // pop one element
            --spCtx->uiUsed;
            vpReturn = (void*)(spCtx->cpData + (spCtx->uiUsed * spCtx->uiElementSize));
          }
  }
  // return a pointer to the popped element
  return vpReturn;
}
 
void* vpVecPopn(void* vpCtx, apg_uint uiCount)
{
  void*       vpReturn = NULL;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          if(uiCount > 0){
                  if(spCtx->uiUsed > 0){
                          if(spCtx->uiUsed > uiCount)
                          {
                            // pop uiCount elements
                            spCtx->uiUsed -= uiCount;
                            vpReturn = (void*)(spCtx->cpData + (spCtx->uiUsed * spCtx->uiElementSize));
                          }
                          else
                          {
                            // pop all remaining elements
                            spCtx->uiUsed = 0;
                            vpReturn = spCtx->cpData;
                          }
                  }
          }
  }
  return vpReturn;
}
 
void* vpVecPopTo(void* vpCtx, apg_uint uiIndex)
{
  void*       vpReturn = NULL;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          if(!(spCtx->uiUsed == 0 || uiIndex >= spCtx->uiUsed)){
 
                  // success
                  spCtx->uiUsed = uiIndex;
                  vpReturn = (void*)(spCtx->cpData + uiIndex);
          }
  }
  return vpReturn;
}
 
void* vpVecFront(void* vpCtx)
{
  void*       vpReturn = NULL;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          if(spCtx->uiUsed)
          {
            vpReturn = (void*)spCtx->cpData;
          }
  }
  return vpReturn;
}
 
void* vpVecBack(void* vpCtx)
{
  void*       vpReturn = NULL;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          if(spCtx->uiUsed)
          {
            vpReturn = (void*)(spCtx->cpData + (spCtx->uiUsed - 1) * spCtx->uiElementSize);
          }
  }
  return vpReturn;
}
 
void* vpVecAt(void* vpCtx, apg_uint uiIndex)
{
  void*       vpReturn = NULL;
  APG_VECTOR_CTX* spCtx = (APG_VECTOR_CTX*)vpCtx;
  if(spCtx && spCtx->vpValidate == (void*)spCtx){
          if(uiIndex < spCtx->uiUsed)
          {
            vpReturn = (void*)(spCtx->cpData + (uiIndex * spCtx->uiElementSize));
          }
  }
  return vpReturn;
}
 
// DESCRIPTION: reallocate the buffer
//              - increase the buffer size to double the previous space plus
//                  specified number of elements
//              - copy existing data to the new buffer
//
// FUNCTION: static apg_uint uiGrow
//
//      ARG: 1) APG_VECTOR_CTX* spCtx
//              : pointer to a valid vector context previously returned
//                from vpVecCtor()
//
//      ARG: 2) apg_uint uiElements
//              : minimum number of elements to make additional room for
//
//   RETURN: true on success, false on failure
//
static apg_uint uiGrow(APG_VECTOR_CTX* spCtx, apg_uint uiElements)
{
  apg_uint uiReturn = APG_FALSE;
  void* vpNewData;
  apg_uint uiReserved;
 
  // allocate new space
  uiReserved = 2 * (spCtx->uiReserved + uiElements);
  vpNewData = vpMemRealloc(spCtx->vpMemCtx, (void*)spCtx->cpData, spCtx->uiElementSize * uiReserved);
  if(vpNewData){
          // success
          spCtx->cpData = (char*)vpNewData;
          spCtx->uiReserved = uiReserved;
          ++spCtx->uiReallocations;
          uiReturn = APG_TRUE;
  }
  return uiReturn;
}