cml/libcm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
118fd5c92d
libcm/cmSerialize.c

1726 lines
45 KiB
C
Raw Normal View History

Initial commit
2012-10-30 03:52:39 +00:00
#include "cmPrefix.h"
#include "cmGlobal.h"
#include "cmRpt.h"
#include "cmErr.h"
#include "cmCtx.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmLinkedHeap.h"
#include "cmSerialize.h"
#define cmSrVersion (0)
#ifdef cmBIG_ENDIAN
#define _cmSrSwap16(v) (v)
#define _cmSrSwap32(v) (v)
#define _cmSrSwapFl (0)
#else
#define _cmSrSwap16(v) (v)
#define _cmSrSwap32(v) (v)
#define _cmSrSwapFl (1)
#endif
typedef struct
{
const char* label;
unsigned typeId;
unsigned byteCnt;
bool swapFl;
} _cmSrPrim_t;
struct _cmSrStruct_str;
// structure field desc record
typedef struct _cmSrField_str
{
const _cmSrPrim_t* primPtr;
struct _cmSrStruct_str* structPtr;
bool arrayFl;
struct _cmSrField_str* linkPtr;
} _cmSrField_t;
// structure description record
typedef struct _cmSrStruct_str
{
unsigned typeId;
_cmSrField_t* fieldList;
struct _cmSrStruct_str* linkPtr;
} _cmSrStruct_t;
// state records track the format for read/write operations
typedef struct _cmSrState_str
{
_cmSrStruct_t* structPtr; // this states current structure
_cmSrField_t* fieldPtr; // this states current field
struct _cmSrState_str* linkPtr; // prev state on stack
unsigned arrayCnt; // array count for this struct array
unsigned arrayIdx; // current array index for this struct array
} _cmSrState_t;
// data records are formed by each write operation
typedef struct _cmSrData_str
{
unsigned typeId;
unsigned eleCnt;
unsigned byteCnt;
void* dataPtr;
bool arrayFl;
bool swapFl;
struct _cmSrData_str* linkPtr;
} _cmSrData_t;
typedef struct
{
cmErr_t err;
cmLHeapH_t lhH;
_cmSrStruct_t* structList;
_cmSrState_t* wrStackPtr;
_cmSrData_t* wrDataList;
char* wrDataBufPtr;
unsigned wrDataBufByteCnt;
_cmSrState_t* rdStackPtr;
const void* rdDataBufPtr;
unsigned rdDataBufByteCnt;
const char* rdCursorPtr;
unsigned rdVersion;
unsigned rdFlags;
cmSrRC_t lastRC;
} _cmSr_t;
_cmSrPrim_t _cmSrPrimArray[] =
{
{"char", kCharSrId, sizeof(char), false },
{"uchar", kUCharSrId, sizeof(char), false },
{"short", kShortSrId, sizeof(short), true },
{"ushort", kUShortSrId, sizeof(unsigned short), true },
{"int", kIntSrId, sizeof(int), true },
{"uint", kUIntSrId, sizeof(unsigned), true },
{"long", kLongSrId, sizeof(long), true },
{"ulong", kLongSrId, sizeof(unsigned long), true },
{"float", kFloatSrId, sizeof(float), false },
{"double", kDoubleSrId, sizeof(double), false },
{"bool", kBoolSrId, sizeof(bool), sizeof(bool)>1 },
{"<invalid>", kInvalidSrId, 0, false }
};
cmSrH_t cmSrNullHandle = { NULL };
void _cmSrPrint( _cmSr_t* p, const char* fmt, ... )
{
va_list vl;
va_start(vl,fmt);
//p->rptFuncPtr(p->rptUserPtr,fmt,vl);
cmRptVPrintf( p->err.rpt, fmt, vl );
va_end(vl);
}
/*
cmSrRC_t _cmSrErrorV( cmSrRC_t rc, _cmSr_t* p, const char* fmt, va_list vl )
{
const int bufCharCnt = 511;
char buf[bufCharCnt+1];
snprintf(buf,bufCharCnt,"Serializer Error code:%i ",rc);
unsigned n = strlen(buf);
vsnprintf(buf+n,bufCharCnt-n,fmt,vl);
buf[bufCharCnt]=0;
_cmSrPrint(p,"%s\n",buf);
p->lastRC = rc;
return rc;
}
*/
cmSrRC_t _cmSrError( cmSrRC_t rc, _cmSr_t* p, const char* fmt, ... )
{
va_list vl;
va_start(vl,fmt);
cmErrVMsg(&p->err,rc,fmt,vl);
va_end(vl);
return rc;
}
_cmSr_t* _cmSrHandleToPtr( cmSrH_t h )
{
assert( h.h != NULL );
return (_cmSr_t*)h.h;
}
const _cmSrPrim_t* _cmSrIdToPrimPtr( unsigned primId )
{
unsigned i;
for(i=0; _cmSrPrimArray[i].typeId != kInvalidSrId; ++i)
if( _cmSrPrimArray[i].typeId == primId )
return _cmSrPrimArray + i;
return NULL;
}
_cmSrStruct_t* _cmSrIdToStructPtr( _cmSr_t* p, unsigned typeId )
{
_cmSrStruct_t* sp = p->structList;
for(; sp != NULL; sp = sp->linkPtr )
if( sp->typeId == typeId )
return sp;
return NULL;
}
void _cmSrClearStructList( _cmSr_t* p )
{
_cmSrStruct_t* csp = p->structList;
while( csp != NULL )
{
_cmSrStruct_t* nsp = csp->linkPtr;
_cmSrField_t* cfp = csp->fieldList;
while( cfp != NULL )
{
_cmSrField_t* nfp = cfp->linkPtr;
cmLHeapFree(p->lhH,cfp);
cfp = nfp;
}
cmLHeapFree(p->lhH,csp);
csp = nsp;
}
p->structList = NULL;
}
void _cmSrClearDataList( _cmSr_t* p )
{
_cmSrData_t* cdp = p->wrDataList;
while( cdp != NULL )
{
_cmSrData_t* ndp = cdp->linkPtr;
cmLHeapFree( p->lhH, cdp );
cdp = ndp;
}
p->wrDataList = NULL;
}
cmSrRC_t _cmSrPopStateStack( _cmSr_t* p, _cmSrState_t** stackPtrPtr )
{
cmSrRC_t rc = kOkSrRC;
_cmSrState_t* stackPtr = *stackPtrPtr;
_cmSrState_t* sp = stackPtr;
assert( sp != NULL );
stackPtr = sp->linkPtr;
if( sp->arrayCnt != cmInvalidCnt && sp->arrayIdx != sp->arrayCnt )
rc = _cmSrError( kFormatViolationSrRC, p, "A type %i structure array field promised %i elements but only %i written.",sp->structPtr->typeId,sp->arrayCnt,sp->arrayIdx);
cmLHeapFree(p->lhH,sp);
*stackPtrPtr = stackPtr;
return rc;
}
void _cmSrClearStateStack( _cmSr_t* p, _cmSrState_t** stackPtrPtr )
{
while( *stackPtrPtr != NULL )
if( _cmSrPopStateStack( p, stackPtrPtr ) != kOkSrRC )
break;
}
cmSrRC_t _cmSrFree( _cmSr_t* p )
{
cmSrRC_t rc = kOkSrRC;
_cmSrClearDataList(p);
_cmSrClearStateStack(p,&p->wrStackPtr);
_cmSrClearStateStack(p,&p->rdStackPtr);
cmMemPtrFree(&p->wrDataBufPtr);
cmLHeapDestroy( &p->lhH );
cmMemPtrFree(&p);
return rc;
}
cmSrRC_t cmSrAlloc( cmSrH_t* hp, cmCtx_t* ctx )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = cmMemAllocZ( _cmSr_t, 1 );
cmErrSetup(&p->err,&ctx->rpt,"Serializer");
p->structList = NULL;
p->lastRC = kOkSrRC;
if( cmLHeapIsValid( p->lhH = cmLHeapCreate(1024,ctx)) == false )
{
rc = _cmSrError( kLHeapFailSrRC, p, "Linked heap initialization failed.");
goto errLabel;
}
hp->h = p;
errLabel:
return rc;
}
cmSrRC_t cmSrFree( cmSrH_t* hp )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = NULL;
if( hp == NULL )
return kOkSrRC;
if( cmSrIsValid(*hp) == false )
return kOkSrRC;
p = _cmSrHandleToPtr(*hp);
if(( rc = _cmSrFree(p)) != kOkSrRC )
goto errLabel;
hp->h = NULL;
errLabel:
return rc;
}
bool cmSrIsValid( cmSrH_t h )
{ return h.h != NULL; }
cmSrRC_t cmSrLastErrorCode( cmSrH_t h )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
return p->lastRC;
}
cmSrRC_t cmSrGetAndClearLastErrorCode( cmSrH_t h )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
cmSrRC_t rc = p->lastRC;
p->lastRC = kOkSrRC;
return rc;
}
cmSrRC_t cmSrFmtReset( cmSrH_t h )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
_cmSrClearStructList(p);
p->lastRC = kOkSrRC;
return cmSrWrReset(h);
}
cmSrRC_t cmSrFmtDefineStruct( cmSrH_t h, unsigned structTypeId )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = _cmSrHandleToPtr(h);
_cmSrStruct_t* structPtr = NULL;
assert( structTypeId >= kStructSrId );
if( p->lastRC != kOkSrRC )
return p->lastRC;
if( structTypeId < kStructSrId )
{
rc = _cmSrError( kParamErrSrRC, p, "The structure type id %i is no greater than or equal to %i. (kStructSrId)",structTypeId,kStructSrId );
goto errLabel;
}
if( _cmSrIdToStructPtr( p, structTypeId ) != NULL)
{
rc = _cmSrError( kParamErrSrRC, p, "The structure type id %i is already in use.",structTypeId );
goto errLabel;
}
if(( structPtr = (_cmSrStruct_t*)cmLHeapAllocZ( p->lhH, sizeof(_cmSrStruct_t))) == NULL )
{
rc = _cmSrError( kLHeapFailSrRC, p, "New structure allocate failed.");
goto errLabel;
}
structPtr->typeId = structTypeId;
structPtr->linkPtr = p->structList;
p->structList = structPtr;
errLabel:
return rc;
}
cmSrRC_t _cmSrFmtField( cmSrH_t h, unsigned typeId, bool arrayFl )
{
cmSrRC_t rc = kOkSrRC;
_cmSrStruct_t* structPtr = NULL;
const _cmSrPrim_t* primPtr = NULL;
_cmSrField_t* fieldPtr = NULL;
_cmSrField_t* cfp = NULL;
_cmSrField_t* pfp = NULL;
_cmSr_t* p = _cmSrHandleToPtr(h);
if( p->lastRC != kOkSrRC )
return p->lastRC;
if( typeId >= kStructSrId )
{
if(( structPtr = _cmSrIdToStructPtr( p, typeId )) == NULL )
{
rc = _cmSrError( kParamErrSrRC, p, "The structure associated with the type id %i could not be found.",typeId);
goto errLabel;
}
}
else
{
if( (typeId==kInvalidSrId) || ((primPtr = _cmSrIdToPrimPtr( typeId )) == NULL) )
{
rc = _cmSrError( kParamErrSrRC, p, "Type primitive type id %i is not valid.",typeId);
goto errLabel;
}
}
if(( fieldPtr = (_cmSrField_t*)cmLHeapAllocZ( p->lhH, sizeof(_cmSrField_t))) == NULL )
{
rc = _cmSrError( kLHeapFailSrRC, p, "Field allocation failed for type %i.",typeId );
goto errLabel;
}
fieldPtr->primPtr = primPtr;
fieldPtr->structPtr = structPtr;
fieldPtr->arrayFl = arrayFl;
pfp = NULL;
cfp = p->structList->fieldList;
for(; cfp != NULL; cfp = cfp->linkPtr )
pfp = cfp;
if( pfp == NULL )
p->structList->fieldList = fieldPtr;
else
pfp->linkPtr = fieldPtr;
errLabel:
return rc;
}
cmSrRC_t cmSrFmtStruct( cmSrH_t h, unsigned id ) { return _cmSrFmtField(h,id, false); }
cmSrRC_t cmSrFmtChar( cmSrH_t h ) { return _cmSrFmtField(h,kCharSrId, false); }
cmSrRC_t cmSrFmtUChar( cmSrH_t h ) { return _cmSrFmtField(h,kUCharSrId, false); }
cmSrRC_t cmSrFmtShort( cmSrH_t h ) { return _cmSrFmtField(h,kShortSrId, false); }
cmSrRC_t cmSrFmtUShort( cmSrH_t h ) { return _cmSrFmtField(h,kUShortSrId, false); }
cmSrRC_t cmSrFmtLong( cmSrH_t h ) { return _cmSrFmtField(h,kLongSrId, false); }
cmSrRC_t cmSrFmtULong( cmSrH_t h ) { return _cmSrFmtField(h,kULongSrId, false); }
cmSrRC_t cmSrFmtInt( cmSrH_t h ) { return _cmSrFmtField(h,kIntSrId, false); }
cmSrRC_t cmSrFmtUInt( cmSrH_t h ) { return _cmSrFmtField(h,kUIntSrId, false); }
cmSrRC_t cmSrFmtFloat( cmSrH_t h ) { return _cmSrFmtField(h,kFloatSrId, false); }
cmSrRC_t cmSrFmtDouble( cmSrH_t h ) { return _cmSrFmtField(h,kDoubleSrId, false); }
cmSrRC_t cmSrFmtBool( cmSrH_t h ) { return _cmSrFmtField(h,kBoolSrId, false); }
cmSrRC_t cmSrFmtStructV( cmSrH_t h, unsigned id ){ return _cmSrFmtField(h,id, true); }
cmSrRC_t cmSrFmtCharV( cmSrH_t h ) { return _cmSrFmtField(h,kCharSrId, true); }
cmSrRC_t cmSrFmtUCharV( cmSrH_t h ) { return _cmSrFmtField(h,kUCharSrId, true); }
cmSrRC_t cmSrFmtShortV( cmSrH_t h ) { return _cmSrFmtField(h,kShortSrId, true); }
cmSrRC_t cmSrFmtUShortV( cmSrH_t h ) { return _cmSrFmtField(h,kUShortSrId, true); }
cmSrRC_t cmSrFmtLongV( cmSrH_t h ) { return _cmSrFmtField(h,kLongSrId, true); }
cmSrRC_t cmSrFmtULongV( cmSrH_t h ) { return _cmSrFmtField(h,kULongSrId, true); }
cmSrRC_t cmSrFmtIntV( cmSrH_t h ) { return _cmSrFmtField(h,kIntSrId, true); }
cmSrRC_t cmSrFmtUIntV( cmSrH_t h ) { return _cmSrFmtField(h,kUIntSrId, true); }
cmSrRC_t cmSrFmtFloatV( cmSrH_t h ) { return _cmSrFmtField(h,kFloatSrId, true); }
cmSrRC_t cmSrFmtDoubleV( cmSrH_t h ) { return _cmSrFmtField(h,kDoubleSrId, true); }
cmSrRC_t cmSrFmtBoolV( cmSrH_t h ) { return _cmSrFmtField(h,kBoolSrId, true); }
cmSrRC_t cmSrDefFmt( cmSrH_t h, unsigned structTypeId, ... )
{
cmSrRC_t rc = kOkSrRC;
va_list vl;
va_start(vl,structTypeId);
if((rc = cmSrFmtDefineStruct( h, structTypeId )) != kOkSrRC )
goto errLabel;
unsigned typeId = kCharSrId;
while( typeId != kInvalidSrId )
{
typeId = va_arg(vl,unsigned);
if( typeId == kInvalidSrId )
break;
bool arrayFl = cmIsFlag(typeId,kArraySrFl);
typeId = cmClrFlag(typeId,kArraySrFl);
if(( rc = _cmSrFmtField(h,typeId,arrayFl)) != kOkSrRC )
goto errLabel;
}
errLabel:
va_end(vl);
return rc;
}
cmSrRC_t cmSrFmtPrint( cmSrH_t h )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
cmSrRC_t rc = kOkSrRC;
const _cmSrStruct_t* sp = p->structList;
for(; sp != NULL; sp = sp->linkPtr )
{
_cmSrPrint( p, "struct: %i", sp->typeId );
unsigned indent = 2;
const _cmSrField_t* fp = sp->fieldList;
for(; fp != NULL; fp = fp->linkPtr )
{
unsigned i;
char sp[ indent+1 ];
sp[indent]=0;
for(i=0; i<indent; ++i)
sp[i] = ' ';
if( fp->primPtr != NULL )
_cmSrPrint( p, "%s prim: %i %s%s", sp, fp->primPtr->byteCnt, fp->primPtr->label, fp->arrayFl?"[]":"" );
else
{
_cmSrPrint( p, "%s struct: %i %s", sp, fp->structPtr->typeId, fp->arrayFl?"[]":"" );
indent += 2;
}
}
}
_cmSrPrint(p,"\n");
return rc;
}
cmSrRC_t _cmSrPushStateStack( _cmSr_t* p, unsigned structTypeId, _cmSrState_t** stackPtrPtr )
{
cmSrRC_t rc = kOkSrRC;
_cmSrStruct_t* refStructPtr;
_cmSrState_t* stackPtr = *stackPtrPtr;
// if this is the base structure then the wr stack will be empty
if( stackPtr == NULL )
refStructPtr = p->structList;
else
{
// the wr stack contains members so this structure type should be the same as the current field type
assert( stackPtr->fieldPtr != NULL );
refStructPtr = stackPtr->fieldPtr->structPtr;
}
// no reference structure exists
if( refStructPtr == NULL )
{
// if the write state stack is empty then the structList must also be empty
if( stackPtr == NULL )
{
rc = _cmSrError( kFormatViolationSrRC, p, "Cannot write data without first providing the data format.");
goto errLabel;
}
else
{
// the data format has been described but the current format field is not a structure
assert( stackPtr->fieldPtr->primPtr != NULL );
rc = _cmSrError( kFormatViolationSrRC, p, "Format violation. Expected primitive type:'%s'.", cmStringNullGuard(stackPtr->fieldPtr->primPtr->label ));
goto errLabel;
}
}
// if wrong type of structure
if( refStructPtr->typeId != structTypeId )
{
rc = _cmSrError( kFormatViolationSrRC, p, "Format violation. Expected structure type:%i instead of structure type:%i.",refStructPtr->typeId,structTypeId );
goto errLabel;
}
// allocate the new structure state
_cmSrState_t* wsp = (_cmSrState_t*)cmLHeapAllocZ( p->lhH, sizeof(_cmSrState_t));
assert( wsp != NULL );
// push the new structure state on the stack
wsp->structPtr = refStructPtr;
wsp->fieldPtr = NULL;
wsp->linkPtr = stackPtr;
wsp->arrayCnt = cmInvalidCnt;
wsp->arrayIdx = cmInvalidIdx;
stackPtr = wsp;
*stackPtrPtr = stackPtr;
errLabel:
return rc;
}
cmSrRC_t cmSrWrReset( cmSrH_t h )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = _cmSrHandleToPtr(h);
_cmSrClearStateStack(p,&p->wrStackPtr);
p->wrStackPtr = NULL;
_cmSrClearDataList(p);
cmMemPtrFree(&p->wrDataBufPtr);
p->wrDataBufByteCnt = 0;
return rc;
}
cmSrRC_t _cmSrOnStruct( _cmSr_t* p, unsigned structTypeId, _cmSrState_t** stackPtrPtr )
{
cmSrRC_t rc = kOkSrRC;
if( p->lastRC != kOkSrRC )
return p->lastRC;
if((rc = _cmSrPushStateStack(p,structTypeId,stackPtrPtr)) != kOkSrRC )
goto errLabel;
_cmSrState_t* stackPtr = *stackPtrPtr;
// the base structure is never an array so it's linkPtr is NULL
if( stackPtr->linkPtr != NULL )
{
stackPtr->linkPtr->arrayIdx += 1;
if( stackPtr->linkPtr->arrayIdx > stackPtr->linkPtr->arrayCnt )
{
rc = _cmSrError( kFormatViolationSrRC, p, "The structure array is out of bounds (array count:%i).",stackPtr->linkPtr->arrayIdx );
goto errLabel;
}
}
*stackPtrPtr = stackPtr;
errLabel:
return rc;
}
cmSrRC_t cmSrWrStructBegin( cmSrH_t h, unsigned structTypeId )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
return _cmSrOnStruct( p, structTypeId, &p->wrStackPtr );
}
cmSrRC_t cmSrWrStructEnd( cmSrH_t h )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
assert( p->wrStackPtr != NULL );
if( p->lastRC != kOkSrRC )
return p->lastRC;
return _cmSrPopStateStack(p, &p->wrStackPtr);
}
cmSrRC_t _cmSrWrField( cmSrH_t h, unsigned typeId, const void* dataPtr, unsigned eleCnt )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = _cmSrHandleToPtr(h);
_cmSrField_t* refFieldPtr = NULL;
unsigned refTypeId = cmInvalidId;
unsigned dataByteCnt = 0;
_cmSrData_t* dataRecdPtr = NULL;
bool swapFl = false;
if( p->lastRC != kOkSrRC )
return p->lastRC;
// verify the write stack exists
if( p->wrStackPtr == NULL )
{
rc = _cmSrError( kFormatViolationSrRC, p, "The reference format is unexpectedly empty.");
goto errLabel;
}
//
// advance the current field
//
// if cur state fieldPtr is NULL then this is the first field in a structure
if( p->wrStackPtr->fieldPtr == NULL )
p->wrStackPtr->fieldPtr = p->wrStackPtr->structPtr->fieldList;
else
p->wrStackPtr->fieldPtr = p->wrStackPtr->fieldPtr->linkPtr;
// verify that a reference field exists
refFieldPtr = p->wrStackPtr->fieldPtr;
if( refFieldPtr == NULL )
{
rc = _cmSrError( kFormatViolationSrRC, p, "The format reference structure has run out of fields.");
goto errLabel;
}
// validate the array status of this field
if( refFieldPtr->arrayFl==false && eleCnt>1 )
{
rc = _cmSrError( kFormatViolationSrRC, p, "The format reference indicates that this field is not an array however an array element count (%i) was given.",eleCnt);
goto errLabel;
}
// get the reference type id
refTypeId = refFieldPtr->primPtr == NULL ? refFieldPtr->structPtr->typeId : refFieldPtr->primPtr->typeId;
// verify that the type being written matches the reference type
if( refTypeId != typeId )
{
const char* refLbl = "struct";
const char* cmtLbl = refLbl;
if( refFieldPtr->primPtr != NULL )
refLbl = refFieldPtr->primPtr->label;
if( typeId < kStructSrId )
cmtLbl = _cmSrIdToPrimPtr( typeId )->label;
rc = _cmSrError( kFormatViolationSrRC, p, "Format violation: Exepected type %i (%s) but received %i (%s).", refTypeId,refLbl,typeId,cmtLbl);
goto errLabel;
}
if( typeId < kStructSrId )
{
dataByteCnt += refFieldPtr->primPtr->byteCnt * eleCnt;
swapFl = refFieldPtr->primPtr->swapFl && _cmSrSwapFl;
}
else
{
p->wrStackPtr->arrayCnt = eleCnt;
p->wrStackPtr->arrayIdx = 0;
}
dataRecdPtr = (_cmSrData_t*)cmLHeapAllocZ( p->lhH, sizeof(_cmSrData_t) + dataByteCnt );
// iniit the new data recd
dataRecdPtr->typeId = typeId;
dataRecdPtr->eleCnt = eleCnt;
dataRecdPtr->byteCnt = dataByteCnt;
dataRecdPtr->arrayFl = refFieldPtr->arrayFl;
dataRecdPtr->swapFl = swapFl;
dataRecdPtr->linkPtr = NULL;
dataRecdPtr->dataPtr = dataRecdPtr + 1;
if( dataByteCnt > 0 )
memcpy( dataRecdPtr->dataPtr, dataPtr, dataByteCnt );
// link the new data recd to the end of the data chain
_cmSrData_t* dp = p->wrDataList;
for(; dp != NULL; dp = dp->linkPtr )
if( dp->linkPtr == NULL )
break;
if( p->wrDataList == NULL )
p->wrDataList = dataRecdPtr;
else
dp->linkPtr = dataRecdPtr;
errLabel:
return rc;
}
cmSrRC_t cmSrWrStruct( cmSrH_t h, unsigned structTypeId, unsigned eleCnt )
{ return _cmSrWrField(h,structTypeId,NULL,eleCnt); }
cmSrRC_t cmSrWrChar( cmSrH_t h, char val )
{ return _cmSrWrField(h,kCharSrId,&val,1); }
cmSrRC_t cmSrWrUChar( cmSrH_t h, unsigned char val )
{ return _cmSrWrField(h,kUCharSrId,&val,1); }
cmSrRC_t cmSrWrShort( cmSrH_t h, short val )
{ return _cmSrWrField(h,kShortSrId,&val,1); }
cmSrRC_t cmSrWrUShort( cmSrH_t h, unsigned short val )
{ return _cmSrWrField(h,kUShortSrId,&val,1); }
cmSrRC_t cmSrWrLong( cmSrH_t h, long val )
{ return _cmSrWrField(h,kLongSrId,&val,1); }
cmSrRC_t cmSrWrULong( cmSrH_t h, unsigned long val )
{ return _cmSrWrField(h,kULongSrId,&val,1); }
cmSrRC_t cmSrWrInt( cmSrH_t h, int val )
{ return _cmSrWrField(h,kIntSrId,&val,1); }
cmSrRC_t cmSrWrUInt( cmSrH_t h, unsigned val )
{ return _cmSrWrField(h,kUIntSrId,&val,1); }
cmSrRC_t cmSrWrFloat( cmSrH_t h, float val )
{ return _cmSrWrField(h,kFloatSrId,&val,1); }
cmSrRC_t cmSrWrDouble( cmSrH_t h, double val )
{ return _cmSrWrField(h,kDoubleSrId,&val,1); }
cmSrRC_t cmSrWrBool( cmSrH_t h, bool val )
{ return _cmSrWrField(h,kBoolSrId,&val,1); }
cmSrRC_t cmSrWrStr( cmSrH_t h, const char* val )
{
const char* ns = "";
if( val == NULL )
val = ns;
return _cmSrWrField(h,kCharSrId,val,strlen(val)+1);
}
cmSrRC_t _cmSrWrArrayField( cmSrH_t h, unsigned typeId, const void* val, unsigned eleCnt )
{
if( val == NULL || eleCnt == 0 )
{
val = NULL;
eleCnt = 0;
}
return _cmSrWrField(h,typeId,val,eleCnt);
}
cmSrRC_t cmSrWrCharV( cmSrH_t h, const char* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kCharSrId,val,eleCnt); }
cmSrRC_t cmSrWrUCharV( cmSrH_t h, const unsigned char* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kUCharSrId,val,eleCnt); }
cmSrRC_t cmSrWrShortV( cmSrH_t h, const short* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kShortSrId,val,eleCnt); }
cmSrRC_t cmSrWrUShortV( cmSrH_t h, const unsigned short* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kUShortSrId,val,eleCnt); }
cmSrRC_t cmSrWrLongV( cmSrH_t h, const long* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kLongSrId,val,eleCnt); }
cmSrRC_t cmSrWrULongV( cmSrH_t h, const unsigned long* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kULongSrId,val,eleCnt); }
cmSrRC_t cmSrWrIntV( cmSrH_t h, const int* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kIntSrId,val,eleCnt); }
cmSrRC_t cmSrWrUIntV( cmSrH_t h, const unsigned* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kUIntSrId,val,eleCnt); }
cmSrRC_t cmSrWrFloatV( cmSrH_t h, const float* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kFloatSrId,val,eleCnt); }
cmSrRC_t cmSrWrDoubleV( cmSrH_t h, const double* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kDoubleSrId,val,eleCnt); }
cmSrRC_t cmSrWrBoolV( cmSrH_t h, const bool* val, unsigned eleCnt )
{ return _cmSrWrArrayField(h,kBoolSrId,val,eleCnt); }
void _cmSrCopyDataToBuf( void* dstPtr, const void* srcPtr, unsigned byteCnt, unsigned typeId, bool swapFl, unsigned eleCnt )
{
if( !swapFl )
{
memcpy(dstPtr,srcPtr,byteCnt);
return;
}
switch( typeId )
{
case kShortSrId:
case kUShortSrId:
{
unsigned i;
const short* sp = (const short*)srcPtr;
short* dp = (short*)dstPtr;
for(i=0; i<eleCnt; ++i)
dp[i] = _cmSrSwap16(sp[i]);
}
break;
case kLongSrId:
case kULongSrId:
case kIntSrId:
case kUIntSrId:
{
unsigned i;
const long* sp = (const long*)srcPtr;
long* dp = (long*)dstPtr;
for(i=0; i<eleCnt; ++i)
dp[i] = _cmSrSwap32(sp[i]);
}
break;
default:
assert(0);
}
}
void* cmSrWrAllocBuf( cmSrH_t h, unsigned* bufByteCntPtr )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
_cmSrData_t* cdp = p->wrDataList;;
assert( bufByteCntPtr != NULL );
*bufByteCntPtr = 0;
p->wrDataBufByteCnt = 2 * sizeof(unsigned); // header words
if( p->lastRC != kOkSrRC )
return NULL;
// determine the data buf size
for(; cdp!=NULL; cdp = cdp->linkPtr )
{
// include spcme for structure type id
if( cdp->typeId >= kStructSrId )
p->wrDataBufByteCnt += sizeof(unsigned);
// include spcme for array element count
if( cdp->arrayFl )
p->wrDataBufByteCnt += sizeof(unsigned);
// include spcme for cmtual data
p->wrDataBufByteCnt += cdp->byteCnt;
}
// allocate the data buffer
p->wrDataBufPtr = cmMemResizeZ( char, p->wrDataBufPtr, p->wrDataBufByteCnt );
cdp = p->wrDataList;
char* dp = p->wrDataBufPtr;
char* ep = dp + p->wrDataBufByteCnt;
// header version
*(unsigned*)dp = _cmSrSwap32(cmSrVersion);
dp += sizeof(unsigned);
// header flags
*(unsigned*)dp = _cmSrSwap32(0);
dp += sizeof(unsigned);
// fill the data buffer
for(; cdp!=NULL; cdp=cdp->linkPtr)
{
// structure data records contain only the typeId and optionally an array count
if( cdp->typeId >= kStructSrId )
{
*((unsigned*)dp) = _cmSrSwap32(cdp->typeId);
dp += sizeof(unsigned);
assert(dp <= ep);
}
// array data elements begin with a element count
if( cdp->arrayFl )
{
*((unsigned*)dp) = _cmSrSwap32(cdp->eleCnt);
dp += sizeof(unsigned);
assert(dp <= ep);
}
// copy data into buf
if( cdp->byteCnt > 0 )
{
assert( cdp->typeId < kStructSrId );
_cmSrCopyDataToBuf(dp, cdp->dataPtr, cdp->byteCnt, cdp->typeId, cdp->swapFl, cdp->eleCnt );
//memcpy( dp, cdp->dataPtr, cdp->byteCnt );
dp += cdp->byteCnt;
assert(dp <= ep);
}
}
*bufByteCntPtr = p->wrDataBufByteCnt;
_cmSrClearDataList(p);
return p->wrDataBufPtr;
}
void* cmSrWrGetBuf( cmSrH_t h, unsigned* bufByteCntPtr )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
assert( bufByteCntPtr != NULL);
*bufByteCntPtr = p->wrDataBufByteCnt;
return p->wrDataBufPtr;
}
unsigned _cmSrProcUInt( _cmSr_t* p )
{
unsigned val = _cmSrSwap32(*(unsigned*)p->rdCursorPtr);
*(unsigned*)p->rdCursorPtr = val;
p->rdCursorPtr += sizeof(unsigned);
return val;
}
cmSrRC_t _cmSrProcBuf( _cmSr_t* p, _cmSrStruct_t* structPtr )
{
cmSrRC_t rc = kOkSrRC;
const _cmSrField_t* cfp = structPtr->fieldList;
for(; cfp != NULL; cfp = cfp->linkPtr )
{
unsigned eleCnt = 1;
// if this is a structure
if( cfp->structPtr != NULL )
{
unsigned structTypeId = _cmSrProcUInt(p);
if( structTypeId != cfp->structPtr->typeId )
{
rc = _cmSrError( kFormatViolationSrRC, p, "Expected type id:%i encountered type id:%i",cfp->structPtr->typeId,structTypeId);
goto errLabel;
}
}
// if this is an array
if( cfp->arrayFl )
eleCnt = _cmSrProcUInt(p);
// if this is a primitive type
if( cfp->primPtr != NULL )
{
unsigned dataByteCnt = eleCnt * cfp->primPtr->byteCnt;
_cmSrCopyDataToBuf( (void*)p->rdCursorPtr, p->rdCursorPtr, dataByteCnt, cfp->primPtr->typeId, cfp->primPtr->swapFl & _cmSrSwapFl, eleCnt );
p->rdCursorPtr += dataByteCnt;
}
else // this is a structure type
{
unsigned i;
for(i=0; i<eleCnt; ++i)
if((rc = _cmSrProcBuf(p,cfp->structPtr)) != kOkSrRC )
goto errLabel;
}
}
errLabel:
return rc;
}
cmSrRC_t cmSrRdProcessBuffer( cmSrH_t h, void* buf, unsigned bufByteCnt )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = _cmSrHandleToPtr(h);
p->rdDataBufPtr = buf;
p->rdDataBufByteCnt = bufByteCnt;
p->rdCursorPtr = buf;
// process the header
_cmSrProcUInt(p);
_cmSrProcUInt(p);
if((rc = _cmSrProcBuf(p,p->structList)) != kOkSrRC )
goto errLabel;
errLabel:
return rc;
}
cmSrRC_t cmSrRdSetup( cmSrH_t h, const void* buf, unsigned bufByteCnt )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = _cmSrHandleToPtr(h);
p->rdDataBufPtr = buf;
p->rdDataBufByteCnt = bufByteCnt;
p->rdCursorPtr = buf;
_cmSrClearStateStack(p,&p->rdStackPtr);
p->rdStackPtr = NULL;
// buffer must at least contain a header
assert( bufByteCnt >= 2 * sizeof(unsigned) );
p->rdVersion = (*(unsigned*)p->rdCursorPtr);
p->rdCursorPtr += sizeof(unsigned);
p->rdFlags = (*(unsigned*)p->rdCursorPtr);
p->rdCursorPtr += sizeof(unsigned);
return rc;
}
cmSrRC_t cmSrRdStructBegin( cmSrH_t h, unsigned structTypeId )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
return _cmSrOnStruct( p, structTypeId, &p->rdStackPtr );
}
cmSrRC_t cmSrRdStructEnd( cmSrH_t h )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
assert( p->rdStackPtr != NULL );
if( p->lastRC != kOkSrRC )
return p->lastRC;
return _cmSrPopStateStack(p,&p->rdStackPtr);
}
cmSrRC_t _cmSrRead( _cmSr_t* p, unsigned typeId, const void** dataPtrPtr, unsigned* dataByteCntPtr, unsigned* eleCntPtr )
{
cmSrRC_t rc = kOkSrRC;
_cmSrField_t* refFieldPtr = NULL;
unsigned refTypeId = cmInvalidId;
unsigned eleCnt = 1;
if( eleCntPtr != NULL )
*eleCntPtr = 0;
if( dataByteCntPtr != NULL )
*dataByteCntPtr = 0;
if( dataPtrPtr != NULL )
*dataPtrPtr = NULL;
if( p->lastRC != kOkSrRC )
return p->lastRC;
// verify the write stack exists - all fields exists inside structures so the stack must have at least one element
if( p->rdStackPtr == NULL )
{
rc = _cmSrError( kFormatViolationSrRC, p, "The reference format is unexpectedly empty.");
goto errLabel;
}
//
// advance the current field
//
// if cur state fieldPtr is NULL then this is the first field in a structure
if( p->rdStackPtr->fieldPtr == NULL )
p->rdStackPtr->fieldPtr = p->rdStackPtr->structPtr->fieldList;
else
p->rdStackPtr->fieldPtr = p->rdStackPtr->fieldPtr->linkPtr;
// verify that a reference field exists
refFieldPtr = p->rdStackPtr->fieldPtr;
if( refFieldPtr == NULL )
{
rc = _cmSrError( kFormatViolationSrRC, p, "The format reference structure has run out of fields.");
goto errLabel;
}
// get the reference type id
refTypeId = refFieldPtr->primPtr == NULL ? refFieldPtr->structPtr->typeId : refFieldPtr->primPtr->typeId;
// verify that the type being written matches the reference type
if( refTypeId != typeId )
{
const char* refLbl = "struct";
const char* cmtLbl = refLbl;
if( refFieldPtr->primPtr != NULL )
refLbl = refFieldPtr->primPtr->label;
if( typeId < kStructSrId )
cmtLbl = _cmSrIdToPrimPtr( typeId )->label;
rc = _cmSrError( kFormatViolationSrRC, p, "Format violation: Exepected type %i (%s) but received %i (%s).", refTypeId,refLbl,typeId,cmtLbl);
goto errLabel;
}
// if this is a primitive type
if( typeId < kStructSrId )
{
unsigned byteCnt = refFieldPtr->primPtr->byteCnt;
if( refFieldPtr->arrayFl )
{
eleCnt = *(unsigned*)p->rdCursorPtr;
byteCnt *= eleCnt;
p->rdCursorPtr += sizeof(unsigned);
if( eleCntPtr == NULL )
{
rc = _cmSrError( kFormatViolationSrRC, p, "A scalar read was performed where an array was expected. type:%s array count:%i.",refFieldPtr->primPtr->label,eleCnt);
goto errLabel;
}
*eleCntPtr = eleCnt;
}
*dataPtrPtr = p->rdCursorPtr;
*dataByteCntPtr = byteCnt;
p->rdCursorPtr += byteCnt;
}
else // this is a structure type
{
unsigned structTypeId = structTypeId = *(unsigned*)p->rdCursorPtr;
p->rdCursorPtr += sizeof(unsigned);
if( refFieldPtr->arrayFl )
{
eleCnt = *(unsigned*)p->rdCursorPtr;
p->rdCursorPtr += sizeof(unsigned);
}
p->rdStackPtr->arrayCnt = eleCnt;
p->rdStackPtr->arrayIdx = 0;
assert(eleCntPtr != NULL );
*eleCntPtr = eleCnt;
}
errLabel:
return rc;
}
cmSrRC_t cmSrReadStruct( cmSrH_t h, unsigned structTypeId, unsigned* arrayCnt )
{
_cmSr_t* p = _cmSrHandleToPtr(h);
return _cmSrRead(p, structTypeId, NULL, NULL, arrayCnt );
}
cmSrRC_t _cmSrReadScalar( cmSrH_t h, unsigned typeId, void* valPtr, unsigned scalarByteCnt )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = _cmSrHandleToPtr(h);
const void* dataPtr = NULL;
unsigned dataByteCnt = 0;
if((rc= _cmSrRead(p,typeId, &dataPtr, &dataByteCnt, NULL )) != kOkSrRC )
return rc;
memcpy(valPtr,dataPtr,dataByteCnt);
return rc;
}
cmSrRC_t _cmSrReadV( cmSrH_t h, unsigned typeId, const void** valPtrPtr, unsigned scalarByteCnt, unsigned* eleCntPtr )
{
cmSrRC_t rc = kOkSrRC;
_cmSr_t* p = _cmSrHandleToPtr(h);
unsigned dataByteCnt = 0;
if((rc= _cmSrRead(p,typeId, valPtrPtr, &dataByteCnt, eleCntPtr )) != kOkSrRC )
return rc;
cmSerialize.c : Fixed a typo in an assertion in _cmSrReadV().
2020-03-09 18:44:59 +00:00
assert( dataByteCnt == scalarByteCnt * (*eleCntPtr));
Initial commit
2012-10-30 03:52:39 +00:00
return rc;
}
cmSrRC_t cmSrReadChar( cmSrH_t h, char* valPtr )
{ return _cmSrReadScalar( h, kCharSrId, valPtr, sizeof(char)); }
cmSrRC_t cmSrReadUChar( cmSrH_t h, unsigned char* valPtr )
{ return _cmSrReadScalar( h, kUCharSrId, valPtr, sizeof(unsigned char)); }
cmSrRC_t cmSrReadShort( cmSrH_t h, short* valPtr )
{ return _cmSrReadScalar( h, kShortSrId, valPtr, sizeof(short)); }
cmSrRC_t cmSrReadUShort( cmSrH_t h, unsigned short* valPtr )
{ return _cmSrReadScalar( h, kUShortSrId, valPtr, sizeof(unsigned short)); }
cmSrRC_t cmSrReadLong( cmSrH_t h, long* valPtr)
{ return _cmSrReadScalar( h, kLongSrId, valPtr, sizeof(long)); }
cmSrRC_t cmSrReadULong( cmSrH_t h, unsigned long* valPtr )
{ return _cmSrReadScalar( h, kULongSrId, valPtr, sizeof(unsigned long)); }
cmSrRC_t cmSrReadInt( cmSrH_t h, int* valPtr)
{ return _cmSrReadScalar( h, kIntSrId, valPtr, sizeof(int)); }
cmSrRC_t cmSrReadUInt( cmSrH_t h, unsigned* valPtr )
{ return _cmSrReadScalar( h, kUIntSrId, valPtr, sizeof(unsigned int)); }
cmSrRC_t cmSrReadFloat( cmSrH_t h, float* valPtr )
{ return _cmSrReadScalar( h, kFloatSrId, valPtr, sizeof(float)); }
cmSrRC_t cmSrReadDouble( cmSrH_t h, double* valPtr )
{ return _cmSrReadScalar( h, kDoubleSrId, valPtr, sizeof(double)); }
cmSrRC_t cmSrReadBool( cmSrH_t h, bool* valPtr )
{ return _cmSrReadScalar( h, kBoolSrId, valPtr, sizeof(bool)); }
cmSrRC_t cmSrReadCharV( cmSrH_t h, char** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kCharSrId, (const void**)valPtrPtr, sizeof(char), eleCntPtr); }
cmSrRC_t cmSrReadUCharV( cmSrH_t h, unsigned char** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kUCharSrId, (const void**)valPtrPtr, sizeof(unsigned char), eleCntPtr); }
cmSrRC_t cmSrReadShortV( cmSrH_t h, short** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kShortSrId, (const void**)valPtrPtr, sizeof(short), eleCntPtr); }
cmSrRC_t cmSrReadUShortV( cmSrH_t h, unsigned short** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kUShortSrId, (const void**)valPtrPtr, sizeof(unsigned short), eleCntPtr); }
cmSrRC_t cmSrReadLongV( cmSrH_t h, long** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kLongSrId, (const void**)valPtrPtr, sizeof(long), eleCntPtr); }
cmSrRC_t cmSrReadULongV( cmSrH_t h, unsigned long** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kULongSrId, (const void**)valPtrPtr, sizeof(unsigned long), eleCntPtr); }
cmSrRC_t cmSrReadIntV( cmSrH_t h, int** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kIntSrId, (const void**)valPtrPtr, sizeof(int), eleCntPtr); }
cmSrRC_t cmSrReadUIntV( cmSrH_t h, unsigned** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kUIntSrId, (const void**)valPtrPtr, sizeof(unsigned int), eleCntPtr); }
cmSrRC_t cmSrReadFloatV( cmSrH_t h, float** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kFloatSrId, (const void**)valPtrPtr, sizeof(float), eleCntPtr); }
cmSrRC_t cmSrReadDoubleV( cmSrH_t h, double** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kDoubleSrId, (const void**)valPtrPtr, sizeof(double), eleCntPtr); }
cmSrRC_t cmSrReadBoolV( cmSrH_t h, bool** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kBoolSrId, (const void**)valPtrPtr, sizeof(bool), eleCntPtr); }
cmSrRC_t cmSrReadCharCV( cmSrH_t h, const char** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kCharSrId, (const void**)valPtrPtr, sizeof(char), eleCntPtr); }
cmSrRC_t cmSrReadUCharCV( cmSrH_t h, const unsigned char** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kUCharSrId, (const void**)valPtrPtr, sizeof(unsigned char), eleCntPtr); }
cmSrRC_t cmSrReadShortCV( cmSrH_t h, const short** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kShortSrId, (const void**)valPtrPtr, sizeof(short), eleCntPtr); }
cmSrRC_t cmSrReadUShortCV( cmSrH_t h, const unsigned short** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kUShortSrId, (const void**)valPtrPtr, sizeof(unsigned short), eleCntPtr); }
cmSrRC_t cmSrReadLongCV( cmSrH_t h, const long** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kLongSrId, (const void**)valPtrPtr, sizeof(long), eleCntPtr); }
cmSrRC_t cmSrReadULongCV( cmSrH_t h, const unsigned long** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kULongSrId, (const void**)valPtrPtr, sizeof(unsigned long), eleCntPtr); }
cmSrRC_t cmSrReadIntCV( cmSrH_t h, const int** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kIntSrId, (const void**)valPtrPtr, sizeof(int), eleCntPtr); }
cmSrRC_t cmSrReadUIntCV( cmSrH_t h, const unsigned** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kUIntSrId, (const void**)valPtrPtr, sizeof(unsigned int), eleCntPtr); }
cmSrRC_t cmSrReadFloatCV( cmSrH_t h, const float** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kFloatSrId, (const void**)valPtrPtr, sizeof(float), eleCntPtr); }
cmSrRC_t cmSrReadDoubleCV( cmSrH_t h, const double** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kDoubleSrId, (const void**)valPtrPtr, sizeof(double), eleCntPtr); }
cmSrRC_t cmSrReadBoolCV( cmSrH_t h, const bool** valPtrPtr, unsigned* eleCntPtr )
{ return _cmSrReadV( h, kBoolSrId, (const void**)valPtrPtr, sizeof(bool), eleCntPtr); }
unsigned cmSrRdStruct( cmSrH_t h, unsigned structTypeId )
{
unsigned eleCnt;
return cmSrReadStruct(h,structTypeId,&eleCnt) == kOkSrRC ? eleCnt : cmInvalidCnt;
}
char cmSrRdChar( cmSrH_t h )
{
char val;
return cmSrReadChar(h,&val) == kOkSrRC ? val : 0;
}
unsigned char cmSrRdUChar( cmSrH_t h )
{
unsigned char val;
return cmSrReadUChar(h,&val) == kOkSrRC ? val : 0;
}
short cmSrRdShort( cmSrH_t h )
{
short val;
return cmSrReadShort(h,&val) == kOkSrRC ? val : 0;
}
unsigned short cmSrRdUShort( cmSrH_t h )
{
unsigned short val;
return cmSrReadUShort(h,&val) == kOkSrRC ? val : 0;
}
long cmSrRdLong( cmSrH_t h )
{
long val;
return cmSrReadLong(h,&val) == kOkSrRC ? val : 0;
}
unsigned long cmSrRdULong( cmSrH_t h )
{
unsigned long val;
return cmSrReadULong(h,&val) == kOkSrRC ? val : 0;
}
int cmSrRdInt( cmSrH_t h )
{
int val;
return cmSrReadInt(h,&val) == kOkSrRC ? val : 0;
}
unsigned int cmSrRdUInt( cmSrH_t h )
{
unsigned val;
return cmSrReadUInt(h,&val) == kOkSrRC ? val : 0;
}
float cmSrRdFloat( cmSrH_t h )
{
float val;
return cmSrReadFloat(h,&val) == kOkSrRC ? val : 0;
}
double cmSrRdDouble( cmSrH_t h )
{
double val;
return cmSrReadDouble(h,&val) == kOkSrRC ? val : 0;
}
bool cmSrRdBool( cmSrH_t h )
{
bool val;
return cmSrReadBool(h,&val) == kOkSrRC ? val : 0;
}
char* cmSrRdCharV( cmSrH_t h, unsigned* eleCntPtr)
{
char* valPtr;
return cmSrReadCharV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
unsigned char* cmSrRdUCharV( cmSrH_t h, unsigned* eleCntPtr)
{
unsigned char* valPtr;
return cmSrReadUCharV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
short* cmSrRdShortV( cmSrH_t h, unsigned* eleCntPtr)
{
short* valPtr;
return cmSrReadShortV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
unsigned short* cmSrRdUShortV( cmSrH_t h, unsigned* eleCntPtr)
{
unsigned short* valPtr;
return cmSrReadUShortV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
long* cmSrRdLongV( cmSrH_t h, unsigned* eleCntPtr)
{
long* valPtr;
return cmSrReadLongV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
unsigned long* cmSrRdULongV( cmSrH_t h, unsigned* eleCntPtr)
{
unsigned long* valPtr;
return cmSrReadULongV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
int* cmSrRdIntV( cmSrH_t h, unsigned* eleCntPtr)
{
int* valPtr;
return cmSrReadIntV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
unsigned int* cmSrRdUIntV( cmSrH_t h, unsigned* eleCntPtr)
{
unsigned* valPtr;
return cmSrReadUIntV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
float* cmSrRdFloatV( cmSrH_t h, unsigned* eleCntPtr)
{
float* valPtr;
return cmSrReadFloatV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
double* cmSrRdDoubleV( cmSrH_t h, unsigned* eleCntPtr)
{
double* valPtr;
return cmSrReadDoubleV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
bool* cmSrRdBoolV( cmSrH_t h, unsigned* eleCntPtr)
{
bool* valPtr;
return cmSrReadBoolV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const char* cmSrRdCharCV( cmSrH_t h, unsigned* eleCntPtr)
{
const char* valPtr;
return cmSrReadCharCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const unsigned char* cmSrRdUCharCV( cmSrH_t h, unsigned* eleCntPtr)
{
const unsigned char* valPtr;
return cmSrReadUCharCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const short* cmSrRdShortCV( cmSrH_t h, unsigned* eleCntPtr)
{
const short* valPtr;
return cmSrReadShortCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const unsigned short* cmSrRdUShortCV( cmSrH_t h, unsigned* eleCntPtr)
{
const unsigned short* valPtr;
return cmSrReadUShortCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const long* cmSrRdLongCV( cmSrH_t h, unsigned* eleCntPtr)
{
const long* valPtr;
return cmSrReadLongCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const unsigned long* cmSrRdULongCV( cmSrH_t h, unsigned* eleCntPtr)
{
const unsigned long* valPtr;
return cmSrReadULongCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const int* cmSrRdIntCV( cmSrH_t h, unsigned* eleCntPtr)
{
const int* valPtr;
return cmSrReadIntCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const unsigned int* cmSrRdUIntCV( cmSrH_t h, unsigned* eleCntPtr)
{
const unsigned* valPtr;
return cmSrReadUIntCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const float* cmSrRdFloatCV( cmSrH_t h, unsigned* eleCntPtr)
{
const float* valPtr;
return cmSrReadFloatCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const double* cmSrRdDoubleCV( cmSrH_t h, unsigned* eleCntPtr)
{
const double* valPtr;
return cmSrReadDoubleCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
const bool* cmSrRdBoolCV( cmSrH_t h, unsigned* eleCntPtr)
{
const bool* valPtr;
return cmSrReadBoolCV(h,&valPtr,eleCntPtr) == kOkSrRC ? valPtr : NULL;
}
//{ { label:cmSerialEx }
//(
// cmSrTest() is a serializer example function.
//)
//[
cmSrRC_t cmSrTest( cmCtx_t* ctx )
{
unsigned i,j,k;
cmSrRC_t rc = kOkSrRC;
cmSrH_t h;
unsigned bufByteCnt;
const void* bufPtr;
enum
{
kVectSrId = kStructSrId, // nested structure id
kVectArrSrId // outer structure id
};
// nested structure
typedef struct
{
float* data;
unsigned cnt;
} vect;
// outer structure
typedef struct
{
unsigned cnt;
vect* vectArray;
} vectArray;
float vd0[] = { 0, 1, 2, 3, 4};
float vd1[] = { 10, 11, 12 };
unsigned vn = 2;
vect v[] = { {vd0,5}, {vd1,3} };
vectArray va = { vn, v };
if(( rc = cmSrAlloc( &h, ctx )) != kOkSrRC )
goto errLabel;
// repeat format processes to test cmSrFormatReset()
for(k=0; k<2; ++k)
{
cmSrFmtReset(h);
// Define the format of nested structures first
//
// Long Form:
// cmSrFmtDefineStruct(h,kVectSrId);
// cmSrFmtFloatV(h );
// cmSrFmtUInt(h );
//
// Short Form:
cmSrDefFmt(h, kVectSrId, kFloatVSrId, kUIntSrId, kInvalidSrId );
// Define the format of the outer structure last
//
// Long Form:
// cmSrFmtDefineStruct(h,kVectArrSrId);
// cmSrFmtUInt(h );
// cmSrFmtStructV(h, kVectSrId );
//
// Short Form:
cmSrDefFmt(h, kVectArrSrId, kUIntSrId, kVectSrId | kArraySrFl, kInvalidSrId );
cmSrFmtPrint(h);
// repeat write process to test cmSrWrReset()
for(j=0; j<2; ++j)
{
cmSrWrReset(h);
cmSrWrStructBegin( h, kVectArrSrId );
cmSrWrUInt( h, vn );
cmSrWrStruct( h, kVectSrId, vn );
for(i=0; i<vn; ++i)
{
cmSrWrStructBegin( h, kVectSrId );
cmSrWrFloatV( h, va.vectArray[i].data, va.vectArray[i].cnt );
cmSrWrUInt( h, va.vectArray[i].cnt );
cmSrWrStructEnd(h);
}
cmSrWrStructEnd(h);
bufByteCnt = 0;
bufPtr = cmSrWrAllocBuf( h, &bufByteCnt );
}
// The serialized buffer has the following format:
// Words Bytes
// ----- ----- -----------------------------------------
// 1 4 [ uint (2) ]
// 2 8 [ id (11) ][ cnt (2) ]
// 6 24 [ cnt (5) ][0.0][1.0][2.0][3.0][4.0]
// 1 4 [ uint (5) ]
// 4 16 [ cnt (3) ][10.][11.][12.]
// 1 4 [ uint (3) ]
// ----- ----
// 14 60
//
unsigned n0,n1,n2,n3;
const float* fArr;
cmSrRdProcessBuffer(h, (void*)bufPtr, bufByteCnt );
cmSrRdSetup( h, bufPtr, bufByteCnt );
cmSrRdStructBegin( h, kVectArrSrId );
cmSrReadUInt( h, &n0 );
cmSrReadStruct( h, kVectSrId, &n1 );
for(i=0; i<n1; ++i)
{
cmSrRdStructBegin( h, kVectSrId );
cmSrReadFloatCV( h, &fArr, &n2 );
cmSrReadUInt( h, &n3 );
cmSrRdStructEnd( h );
}
cmSrRdSetup( h, bufPtr, bufByteCnt );
cmSrRdStructBegin( h, kVectArrSrId );
n0 = cmSrRdUInt( h );
n1 = cmSrRdStruct( h, kVectSrId );
for(i=0; i<n1; ++i)
{
cmSrRdStructBegin( h, kVectSrId );
fArr = cmSrRdFloatV( h, &n2 );
n3 = cmSrRdUInt( h );
cmSrRdStructEnd( h );
for(j=0; j<n2; ++j)
printf("%f ",fArr[j]);
printf("\n");
}
}
errLabel:
cmSrFree(&h);
return rc;
}
//]
//}
Reference in New Issue Copy Permalink