kSerializer.h

Go to the documentation of this file.

#ifndef K_API_SERIALIZER_H
#define K_API_SERIALIZER_H

#include <kApi/kApiDef.h>
#include <kApi/Data/kArrayList.h>

#include <kApi/Io/kSerializer.x.h>

//typedef kObject kSerializer;   --forward-declared in kApiDef.x.h

kFx(kStatus) kSerializer_Construct(kSerializer* serializer, kStream stream, kType serializerType, kAlloc allocator); 

kFx(kStatus) kSerializer_LoadObject(kObject* object, kType serializerType, const kChar* filePath, kAlloc readAlloc);

kFx(kStatus) kSerializer_SaveObject(kObject object, kType serializerType, const kChar* filePath); 

kFx(kStatus) kSerializer_SetVersion(kSerializer serializer, kAssembly assembly, kVersion version); 

kInlineFx(kStatus) kSerializer_SetSizeEncoding(kSerializer serializer, k32u byteCount)
{
    return xkSerializer_VTable(serializer)->VSetSizeEncoding(serializer, byteCount);
}

kFx(kStatus) kSerializer_SetBufferSize(kSerializer serializer, kSize size);

kInlineFx(kSize) kSerializer_BufferSize(kSerializer serializer)
{
    kObj(kSerializer, serializer);

    return obj->bufferSize;
}

kInlineFx(kStatus) kSerializer_SetMaxBufferedWriteSize(kSerializer serializer, kSize size)
{
    kObj(kSerializer, serializer);

    obj->maxBufferedWriteSize = size; 

    return kOK;
}

kInlineFx(kSize) kSerializer_MaxBufferedWriteSize(kSerializer serializer)
{
    kObj(kSerializer, serializer);

    return obj->maxBufferedWriteSize;
}

kInlineFx(kStatus) kSerializer_EnableObjectFlush(kDat6Serializer serializer, kBool enable)
{
    kObj(kSerializer, serializer);

    obj->objectFlushEnabled = enable;

    return kOK;
}

kInlineFx(kBool) kSerializer_ObjectFlushEnabled(kDat6Serializer serializer)
{
    kObj(kSerializer, serializer);

    return obj->objectFlushEnabled;
}

kInlineFx(k32u) kSerializer_SizeEncoding(kSerializer serializer)
{
    kObj(kSerializer, serializer);

    return obj->sizeEncoding;
}

kInlineFx(kStatus) kSerializer_SetEndianness(kSerializer serializer, kEndianness endianness)
{
    kObj(kSerializer, serializer);

    obj->endianness = endianness; 
    obj->swap = kEndianness_ShouldReverse(obj->endianness); 

    return kOK; 
}

kInlineFx(kEndianness) kSerializer_Endianness(kSerializer serializer)
{
    kObj(kSerializer, serializer);

    return obj->endianness; 
}

kInlineFx(kStatus) kSerializer_WriteObject(kSerializer serializer, kObject object)
{
    return xkSerializer_VTable(serializer)->VWriteObject(serializer, object);
}
kInlineFx(kStatus) kSerializer_ReadObject(kSerializer serializer, kObject* object, kAlloc allocator)
{
    return xkSerializer_VTable(serializer)->VReadObject(serializer, object, allocator);
}

kFx(kStatus) kSerializer_WriteText(kSerializer serializer, const kChar* data); 

kFx(kStatus) kSerializer_ReadText(kSerializer serializer, kChar* data, kSize capacity); 

kInlineFx(kStatus) kSerializer_WriteByte(kSerializer serializer, kByte data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_8); 
}

kInlineFx(kStatus) kSerializer_WriteByteArray(kSerializer serializer, const void* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_8);  
}

kInlineFx(kStatus) kSerializer_ReadByte(kSerializer serializer, kByte* data)
{
    kObj(kSerializer, serializer);

    return kStream_Read(obj->readStream, data, 1); 
}

kInlineFx(kStatus) kSerializer_ReadByteArray(kSerializer serializer, void* data, kSize count)
{
    kObj(kSerializer, serializer);

    return kStream_Read(obj->readStream, data, count); 
}

kInlineFx(kStatus) kSerializer_WriteChar(kSerializer serializer, kChar data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_8); 
}

kInlineFx(kStatus) kSerializer_WriteCharArray(kSerializer serializer, const kChar* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_8);  
}

kInlineFx(kStatus) kSerializer_ReadChar(kSerializer serializer, kChar* data)
{
    kObj(kSerializer, serializer);

    return kStream_Read(obj->readStream, data, 1); 
}

kInlineFx(kStatus) kSerializer_ReadCharArray(kSerializer serializer, kChar* data, kSize count)
{
    kObj(kSerializer, serializer);

    return kStream_Read(obj->readStream, data, count); 
}

kInlineFx(kStatus) kSerializer_Write8u(kSerializer serializer, k8u data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_8); 
}

kInlineFx(kStatus) kSerializer_Write8uArray(kSerializer serializer, const k8u* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_8);  
}

kInlineFx(kStatus) kSerializer_Read8u(kSerializer serializer, k8u* data)
{
    kObj(kSerializer, serializer);

    return kStream_Read(obj->readStream, data, 1); 
}

kInlineFx(kStatus) kSerializer_Read8uArray(kSerializer serializer, k8u* data, kSize count)
{
    kObj(kSerializer, serializer);

    return kStream_Read(obj->readStream, data, count); 
}
kInlineFx(kStatus) kSerializer_Write8s(kSerializer serializer, k8s data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_8); 
}

kInlineFx(kStatus) kSerializer_Write8sArray(kSerializer serializer, const k8s* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_8);  
}

kInlineFx(kStatus) kSerializer_Read8s(kSerializer serializer, k8s* data)
{
    kObj(kSerializer, serializer);

    return kStream_Read(obj->readStream, data, 1); 
}

kInlineFx(kStatus) kSerializer_Read8sArray(kSerializer serializer, k8s* data, kSize count)
{
    kObj(kSerializer, serializer);

    return kStream_Read(obj->readStream, data, count); 
}

kInlineFx(kStatus) kSerializer_Write16u(kSerializer serializer, k16u data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_16); 
}
kInlineFx(kStatus) kSerializer_Write16uArray(kSerializer serializer, const k16u* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_16);  
}

kInlineFx(kStatus) kSerializer_Read16u(kSerializer serializer, k16u* data)
{
    return xkSerializer_ReadPrimitive(serializer, data, xkSERIALIZER_PRIMATIVE_16); 
}

kInlineFx(kStatus) kSerializer_Read16uArray(kSerializer serializer, k16u* data, kSize count)
{
    return xkSerializer_ReadPrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_16);      
}

kInlineFx(kStatus) kSerializer_Write16s(kSerializer serializer, k16s data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_16); 
}

kInlineFx(kStatus) kSerializer_Write16sArray(kSerializer serializer, const k16s* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_16);  
}

kInlineFx(kStatus) kSerializer_Read16s(kSerializer serializer, k16s* data)
{
    return xkSerializer_ReadPrimitive(serializer, data, xkSERIALIZER_PRIMATIVE_16); 
}

kInlineFx(kStatus) kSerializer_Read16sArray(kSerializer serializer, k16s* data, kSize count)
{
    return xkSerializer_ReadPrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_16);      
}

kInlineFx(kStatus) kSerializer_Write32u(kSerializer serializer, k32u data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_32); 
}

kInlineFx(kStatus) kSerializer_Write32uArray(kSerializer serializer, const k32u* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_32);  
}
kInlineFx(kStatus) kSerializer_Read32u(kSerializer serializer, k32u* data)
{
    return xkSerializer_ReadPrimitive(serializer, data, xkSERIALIZER_PRIMATIVE_32); 
}

kInlineFx(kStatus) kSerializer_Read32uArray(kSerializer serializer, k32u* data, kSize count)
{
    return xkSerializer_ReadPrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_32);      
}

kInlineFx(kStatus) kSerializer_Write32s(kSerializer serializer, k32s data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_32); 
}

kInlineFx(kStatus) kSerializer_Write32sArray(kSerializer serializer, const k32s* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_32);  
}

kInlineFx(kStatus) kSerializer_Read32s(kSerializer serializer, k32s* data)
{
    return xkSerializer_ReadPrimitive(serializer, data, xkSERIALIZER_PRIMATIVE_32); 
}

kInlineFx(kStatus) kSerializer_Read32sArray(kSerializer serializer, k32s* data, kSize count)
{
    return xkSerializer_ReadPrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_32);      
}

kInlineFx(kStatus) kSerializer_Write64u(kSerializer serializer, k64u data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_64); 
}

kInlineFx(kStatus) kSerializer_Write64uArray(kSerializer serializer, const k64u* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_64);  
}
kInlineFx(kStatus) kSerializer_Read64u(kSerializer serializer, k64u* data)
{
    return xkSerializer_ReadPrimitive(serializer, data, xkSERIALIZER_PRIMATIVE_64); 
}
kInlineFx(kStatus) kSerializer_Read64uArray(kSerializer serializer, k64u* data, kSize count)
{
    return xkSerializer_ReadPrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_64);      
}

kInlineFx(kStatus) kSerializer_Write64s(kSerializer serializer, k64s data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_64); 
}
kInlineFx(kStatus) kSerializer_Write64sArray(kSerializer serializer, const k64s* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_64);  
}
kInlineFx(kStatus) kSerializer_Read64s(kSerializer serializer, k64s* data)
{
    return xkSerializer_ReadPrimitive(serializer, data, xkSERIALIZER_PRIMATIVE_64); 
}
kInlineFx(kStatus) kSerializer_Read64sArray(kSerializer serializer, k64s* data, kSize count)
{
    return xkSerializer_ReadPrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_64);      
}

kInlineFx(kStatus) kSerializer_Write32f(kSerializer serializer, k32f data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_32); 
}
kInlineFx(kStatus) kSerializer_Write32fArray(kSerializer serializer, const k32f* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_32);  
}
kInlineFx(kStatus) kSerializer_Read32f(kSerializer serializer, k32f* data)
{
    return xkSerializer_ReadPrimitive(serializer, data, xkSERIALIZER_PRIMATIVE_32); 
}
kInlineFx(kStatus) kSerializer_Read32fArray(kSerializer serializer, k32f* data, kSize count)
{
    return xkSerializer_ReadPrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_32);      
}
kInlineFx(kStatus) kSerializer_Write64f(kSerializer serializer, k64f data)
{
    return xkSerializer_WritePrimitive(serializer, &data, xkSERIALIZER_PRIMATIVE_64); 
}
kInlineFx(kStatus) kSerializer_Write64fArray(kSerializer serializer, const k64f* data, kSize count)
{
    return xkSerializer_WritePrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_64);  
}

kInlineFx(kStatus) kSerializer_Read64f(kSerializer serializer, k64f* data)
{
    return xkSerializer_ReadPrimitive(serializer, data, xkSERIALIZER_PRIMATIVE_64); 
}

kInlineFx(kStatus) kSerializer_Read64fArray(kSerializer serializer, k64f* data, kSize count)
{
    return xkSerializer_ReadPrimitives(serializer, data, count, xkSERIALIZER_PRIMATIVE_64);      
}

kInlineFx(kStatus) kSerializer_WriteSize(kSerializer serializer, kSize data)
{
    return xkSerializer_WriteSizePrimitive(serializer, data); 
}

kFx(kStatus) kSerializer_WriteSizeArray(kSerializer serializer, const kSize* data, kSize count);

kInlineFx(kStatus) kSerializer_ReadSize(kSerializer serializer, kSize* data)
{
    return xkSerializer_ReadSizePrimitive(serializer, data); 
}

kFx(kStatus) kSerializer_ReadSizeArray(kSerializer serializer, kSize* data, kSize count);

kInlineFx(kStatus) kSerializer_WriteSSize(kSerializer serializer, kSSize data)
{
    return xkSerializer_WriteSSizePrimitive(serializer, data); 
}

kFx(kStatus) kSerializer_WriteSSizeArray(kSerializer serializer, const kSSize* data, kSize count);

kInlineFx(kStatus) kSerializer_ReadSSize(kSerializer serializer, kSSize* data)
{
    return xkSerializer_ReadSSizePrimitive(serializer, data); 
}

kFx(kStatus) kSerializer_ReadSSizeArray(kSerializer serializer, kSSize* data, kSize count);

kInlineFx(kBool) kSerializer_IsMemoryCompatible(kSerializer serializer, kType type)
{
    return (kSerializer_Endianness(serializer) == kEndianness_Host()) && kType_IsPacked(type); 
}

kInlineFx(kBool) kSerializer_CanWriteType(kSerializer serializer, kType type)
{
    return xkSerializer_VTable(serializer)->VCanWriteType(serializer, type);
}

kInlineFx(kStatus) kSerializer_WriteType(kSerializer serializer, kType type, kTypeVersion* version)
{
    return xkSerializer_VTable(serializer)->VWriteType(serializer, type, version);
}


kInlineFx(kStatus) kSerializer_ReadType(kSerializer serializer, kType* type, kTypeVersion* version)
{
    return xkSerializer_VTable(serializer)->VReadType(serializer, type, version);
}

kFx(kStatus) kSerializer_WriteItems(kSerializer serializer, kType type, kTypeVersion version, const void* items, kSize count); 

#define kSerializer_WriteItemsT(kSerializer_serializer, kType_type, kTypeVersion_version, TPtr_items, kSize_count) \
    xkSerializer_WriteItemsT(kSerializer_serializer, kType_type, kTypeVersion_version, TPtr_items, kSize_count, sizeof(*(TPtr_items)))

kFx(kStatus) kSerializer_ReadItems(kSerializer serializer, kType type, kTypeVersion version, void* items, kSize count); 

#define kSerializer_ReadItemsT(kSerializer_serializer, kType_type, kTypeVersion_version, TPtr_items, kSize_count) \
    xkSerializer_ReadItemsT(kSerializer_serializer, kType_type, kTypeVersion_version, TPtr_items, kSize_count, sizeof(*(TPtr_items)))

kFx(kStatus) kSerializer_BeginWrite(kSerializer serializer, kType sizeType, kBool includeSize); 

kFx(kStatus) kSerializer_EndWrite(kSerializer serializer); 

kInlineFx(kStatus) kSerializer_AdvanceWrite(kSerializer serializer, kSize offset)
{
    if (offset == 0)
    {
        return kOK; 
    }

    return xkSerializer_AdvanceWriteImpl(serializer, offset); 
}

kFx(kStatus) kSerializer_BeginRead(kSerializer serializer, kType sizeType, kBool includeSize); 

kFx(kStatus) kSerializer_EndRead(kSerializer serializer); 

kInlineFx(kBool) kSerializer_ReadCompleted(kSerializer serializer)
{
    kObj(kSerializer, serializer);

    kAssert(kArrayList_Count(obj->readSections) > 0); 

    return kStream_BytesRead(obj->readStream) >= kPointer_ReadAs(kArrayList_Last(obj->readSections), k64u); 
}

kInlineFx(k64u) kSerializer_ReadBytesLeft(kSerializer serializer)
{
    kObj(kSerializer, serializer);

    kAssert(kArrayList_Count(obj->readSections) > 0);

    return kPointer_ReadAs(kArrayList_Last(obj->readSections), k64u) - kStream_BytesRead(obj->readStream); 
}

kInlineFx(kStatus) kSerializer_AdvanceRead(kSerializer serializer, kSize offset)
{
    if (offset == 0)
    {
        return kOK; 
    }

    return xkSerializer_AdvanceReadImpl(serializer, offset); 
}

kInlineFx(kStatus) kSerializer_Flush(kSerializer serializer)
{
    return xkSerializer_FlushEx(serializer, kTRUE);
}

kInlineFx(kStatus) kSerializer_Reset(kSerializer serializer)
{
    return xkSerializer_VTable(serializer)->VReset(serializer);
}

kInlineFx(kStream) kSerializer_Stream(kSerializer serializer)
{  
    kObj(kSerializer, serializer);

    return obj->stream;
}

#endif