ut_memTab.c File Reference

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

#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_load (void *oTab, int iNr, MemTab *mt)
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)
int	MemTab_write (FILE fp1, MemTab mt)
int	MemTab_read (FILE fp1, MemTab mt)

Detailed Description

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

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

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

MemTab_ini          init 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_load         returns datablock and its nr of records
MemTab_get          retrieve (copy out) records 
MemTab_clear        reset  (memTab->rNr = 0;)
MemTab_free         free MemTab-structure.
MemTab_write        write MemTab to file
MemTab_read         read MemTab from file

MEMTAB_IND          get index (pointer to next free = nr of used)  INLINE

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:

#include "../ut/ut_memTab.h"          // MemTab_..
#include "../ut/ut_geo.h"             // Point
// typedef struct {double x, y, z;} Point;

typedef_MemTab(Point);

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

  // 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);

  // print nr of records stored:
  printf(" nr of records: %d\n",pTab.rNr);

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

  f2 (&pTab);

  // free memory
  MemTab_free (&pTab);

  printf(" sizof = %d\n",sizeof(MemTab));
}


// how to loop tru MemTabs:
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;

}

Function Documentation

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

    MemTab_ini           init 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.
    struct must be initialized with MemTab_ini; free it with MemTab_free.
    Fixed Recordsizes only !
    
    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_load	(	void **	oTab,
		int *	iNr,
		MemTab *	mt
	)

    MemTab_load            returns datablock and its nr of records
    use:
      MemTab_load ((void**)&oTab, &iNr, (MemTab*)&delTab);
    see also MemTab_get

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.

int MemTab_write	(	FILE *	fp1,
		MemTab *	mt
	)

int MemTab_read	(	FILE *	fp1,
		MemTab *	mt
	)

ut_memTab.c File Reference

Functions

Detailed Description

Function Documentation