ut_memTab.c File Reference


Detailed Description

Store fixed-length-records in memory: add,insert .. MemTab_.

fixed-length-records: add, insert, delete, ..; reallocate automatic

=====================================================
Liste_Funktionen_Beginn:

MemTab_ini          preset memory-table
MemTab_sav          save objDat to memSpc; malloc/realloc if necessary.
MemTab_ins          insert records in MemTab
MemTab_del          delete records in MemTab
MemTab_mod          modify records 
MemTab_get          retrieve (copy out) records 
MemTab_clear        reset  (memTab->rNr = 0;)
MemTab_free         free MemTab-structure.

Liste_Funktionen_Ende:
=====================================================

- see also:
../doc/gCAD3D_prog_de.txt section Memoryfunktionen


- OFFLINE tests:
main
dumpTab


- external functionreferences:
UTI_round_i2b
UTI_round_b2i
MEM_del_nrec
MEM_ins_nrec


-----------------------------------------------------
- usage examples:

// typedef struct {double x, y, z;} Point;
typedef_MemTab(Point);

int f1 () {
  long          ld;
  Point         pt1, pta[]={{0,0,0},{1,0,0},{1,1,0}};
  MemTab(Point) pTab;

  // alloc for 100 points
  MemTab_ini (&pTab, sizeof(Point), Typ_PT, 100);
  // add records to pTab
  MemTab_sav (&pTab, &ld, &pta[0], 1);   // add 1 record
  MemTab_sav (&pTab, &ld, &pta[1], 2);   // add 2 records

  printf("recNr = %d\n",pTab.rNr);       // nr of records in pTab (Count)

  // get 1 record starting with record # 2
  ii = 0;
  MemTab_get (&pt1, &pTab, 2, 1);
    // dumpTab (&pTab, 2);
    printf(" pt1=%f,%f,%f\n",pt1.x,pt1.y,pt1.z);

  // get 1 record direct out of tab.data:
  // pt1 = pTab.data[ii];

  // insert 1 record before record # 2
  pt1.x = 3; pt1.y = 4; pt1.z = 5;
  MemTab_ins (&pTab, &ld, &pt1, 2, 1);

  // modify 1 record starting with record # 2
  pt1.x = 5; pt1.y = 4; pt1.z = 3;
  MemTab_mod (&pTab, &pt1, 2, 1);

  // delete 1 record starting with record # 2
  MemTab_del (&pTab, 2, 1);

  // resets the data (clear)
  // MemTab_clear (&pTab);         // memTab->rNr = 0; 

  f2 (&pTab);

  // free memory
  MemTab_free (&pTab);
}

int f2 (MemTab(Point) *mTb) {
  // mTab->data has type Point* !
  int    i1;
  Point  *pTab;
  
  for(i1=0; i1<=mTb->rNr; ++i1) {
    // data is (Point*) !
    printf(" rec[%d]=%f,%f,%f\n",i1,
            mTb->data[i1].x,
            mTb->data[i1].y,
            mTb->data[i1].z);
  }

  pTab = mTb->data;

  return 0;

}

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "ut_memTab.h"

Functions

int MemTab_ini (MemTab *memTab, int rSiz, int typ, int incSiz)
int MemTab_sav (MemTab *memTab, long *spcOff, void *objDat, int recNr)
int MemTab_get (void *objDat, MemTab *mt, int ipos, int recNr)
int MemTab_mod (MemTab *mt, void *objDat, int ipos, int recNr)
int MemTab_del (MemTab *mt, int ipos, int delRecNr)
int MemTab_ins (MemTab *mt, long *spcOff, void *objDat, int ipos, int insRecNr)
int MemTab_clear (MemTab *memTab)
int MemTab_free (MemTab *memTab)


Function Documentation

int MemTab_ini ( MemTab *  memTab,
int  rSiz,
int  typ,
int  incSiz 
)

    MemTab_ini           preset memory-table
    use MemTab for a list of records;
    use memSpc for a different types of records in the same memoryblock.
    
    INPUT:
      rSiz    recordsize in bytes
      typ     info; Typ_PT=Point Typ_Int4=int Typ_Float8=double Typ_Int1=char;
      incSiz  nr of records to increment memTab;
              if Memspc is too small: add UTI_round_b2i(incSiz * rSiz)

int MemTab_sav ( MemTab *  memTab,
long *  spcOff,
void *  objDat,
int  recNr 
)

    MemTab_sav           save objDat to memSpc; malloc/realloc if necessary.
    Free it with MemTab_free.
    struct must be initialized with MemTab_ini
    
    Input:
      memTab        where to store data; must have type according to objDat.
      objDat        data to be saved in memSpc
      recNr         nr of additional records to be allocated / saved
    Output:
      memTab->rNr   nr of records already in use (including objDat)
      spcOff        displacement-offset; 0: no reallocate.
    RetCode 
      0 = OK; -1 = outOfMemory-Error.
    
    memTab:
      memTab->rMax  nr of records already allocated
      memTab->rNr   nr of records already in use
      memTab->rSiz  recordsize in bytes
    
    Ablauf:
      if (recNr > 0)  get space for <recNr> records.
      else            get space for <recNrFree> records.
      if (objDat == NULL)  do not save, do malloc/realloc.
      recNrFree =  UTI_round_b2i(memTab->incSiz)

int MemTab_get ( void *  objDat,
MemTab *  mt,
int  ipos,
int  recNr 
)

    MemTab_get          retrieve (copy out) records 
      get <recNr> records starting with record <ipos>
    
    Input:
      ipos       1. record to replace in mt->data
      recNr      nr of records to overwrite 
    Output:
      objDat     data out of memSpc
    RetCodes:
       -1        not yet allocated (ipos+recNr > mt->rNr)

int MemTab_mod ( MemTab *  mt,
void *  objDat,
int  ipos,
int  recNr 
)

    MemTab_mod               modify records 
    modify <recNr> records starting with record <ipos>
    
    Input:
      objDat     data to be saved in memSpc
      ipos       1. record to replace in mt->data
      recNr      nr of records to overwrite 
    RetCodes:
       -1        not yet allocated (ipos+recNr > mt->rNr)

int MemTab_del ( MemTab *  mt,
int  ipos,
int  delRecNr 
)

    MemTab_del               delete records in MemTab
      delete <delRecNr> records starting with record <ipos>
    Input:
      ipos       1. record to delete in mt->data
      delRecNr   nr of records to delete 

int MemTab_ins ( MemTab *  mt,
long *  spcOff,
void *  objDat,
int  ipos,
int  insRecNr 
)

    MemTab_ins               insert records in MemTab
      insert <insRecNr> records before record <ipos>

int MemTab_clear ( MemTab *  memTab  ) 

MemTab_clear reset (memTab->rNr = 0;)

int MemTab_free ( MemTab *  memTab  ) 

MemTab_free free MemTab-structure.


Generated on Sat May 30 09:31:56 2009 for gCAD3D by  doxygen 1.5.6