//
// Table BN 3-Mai-98
//
//
//
//
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

#include "WinMain.h"
#include "Table.h"

// *****************************************************************
// vlInit
// *****************************************************************
Table::vlInit (void)
{
VTable_ *pStruktur;


pStruktur = &pVTable;
pStruktur->nStatus = FALSE;
pStruktur->lKeyLaenge = FALSE;
if(pStruktur->InterneListe.vlInit()==TRUE){
pStruktur->nStatus = TRUE;
return(TRUE);
} else {
return(FALSE);
}
}

// *****************************************************************
// vlnew
// *****************************************************************
Table::vlnew (void *pKey, long lKeyLaenge, void *pBuffer, long lLaenge)
{
int nRet=FALSE;
long lWert;


if(pVTable.nStatus==TRUE){
if(pVTable.InterneListe.vlnew (pBuffer, (lKeyLaenge + lLaenge))==TRUE){
if(pVTable.lKeyLaenge==0){
pVTable.lKeyLaenge = lKeyLaenge;
}
memcpy(&lWert, pBuffer, sizeof(long));
memcpy((char *)lWert, pKey, pVTable.lKeyLaenge);

lWert = (long)(lWert + pVTable.lKeyLaenge);
memcpy(pBuffer, &lWert, sizeof(long));
nRet = TRUE;
}
}
return(nRet);
}

// *****************************************************************
// vlread
// *****************************************************************
Table::vlread (void *pKey, void *pBuffer)
{
int nRet=FALSE;
int nEnde=FALSE;
long lWert;
long *lWert2;
long lAltePosition;
long lKeyLaenge;
char *acKey;


if(pVTable.nStatus==TRUE){
pVTable.InterneListe.vlreq (pBuffer, &lAltePosition);
pVTable.InterneListe.vlroot();
while(nEnde==FALSE && pVTable.InterneListe.vlnext(pBuffer)==TRUE){
memcpy(&acKey, &pKey, sizeof(long));
lKeyLaenge = pVTable.lKeyLaenge;
if((signed)strlen(acKey)<lKeyLaenge){
lKeyLaenge = (signed)strlen(acKey);
}
memcpy(&lWert2, pBuffer, sizeof(long));
if(memcmp(pKey, (char *)(lWert2), lKeyLaenge)==0){
memcpy(&lWert, pBuffer, sizeof(long));
lWert = (long)(lWert + pVTable.lKeyLaenge);
memcpy(pBuffer, &lWert, sizeof(long));
nEnde = TRUE;
nRet = TRUE;
}
}
if(nEnde==FALSE){
pVTable.InterneListe.vlnum(lAltePosition, pBuffer);
memcpy(&lWert, pBuffer, sizeof(long));
lWert = (long)(lWert + pVTable.lKeyLaenge);
memcpy(pBuffer, &lWert, sizeof(long));
}
}
return(nRet);
}

// *****************************************************************
// vldelet *
// *****************************************************************
Table::vldelet (void *pKey, void *pBuffer)
{
int nRet=FALSE;
long lWert;


if(pVTable.nStatus==TRUE){
if(Table::vlread(pKey, pBuffer)){
if(pVTable.InterneListe.vldelet(pBuffer)){
if(pVTable.InterneListe.vlread(pBuffer)==TRUE){
lWert = (long)(lWert + pVTable.lKeyLaenge);
memcpy(pBuffer, &lWert, sizeof(long));
nRet = TRUE;
}
}
}
}
return(nRet);
}

// *****************************************************************
// vlreq
// *****************************************************************
Table::vlreq (void *pKey, void *pBuffer, long *lPosition)
{
int nRet=FALSE;


if(pVTable.nStatus==TRUE){
*lPosition = 0;
if(Table::vlread(pKey, pBuffer)){
if(pVTable.InterneListe.vlreq(pBuffer, lPosition)){
nRet = TRUE;
}
}
}
return(nRet);
}

// *****************************************************************
// vlroot
// *****************************************************************
Table::vlroot (void)
{
int nRet=FALSE;


if(pVTable.nStatus==TRUE){
if(pVTable.InterneListe.vlroot()){
nRet = TRUE;
}
}
return(nRet);
}

// *****************************************************************
// vlnext
// *****************************************************************
Table::vlnext (void *pBuffer)
{
int nRet=FALSE;


if(pVTable.nStatus==TRUE){
if(pVTable.InterneListe.vlnext(pBuffer)){
nRet = TRUE;
}
}
return(nRet);
}

// *****************************************************************
// vlDeInit *
// *****************************************************************
Table::vlDeInit (void)
{
int nRet=FALSE;


if(pVTable.nStatus==TRUE){
if(pVTable.InterneListe.vlDeInit()==TRUE){
pVTable.nStatus = FALSE;
nRet = TRUE;
}
}
return(nRet);
}