kStream.h

Go to the documentation of this file.

#ifndef K_API_STREAM_H
#define K_API_STREAM_H

#include <kApi/kApiDef.h>
#include <kApi/Io/kStream.x.h>

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

/*
* Public 
*/

kInlineFx(kStatus) kStream_Read(kStream stream, void* buffer, kSize size)
{
    kObj(kStream, stream); 

    if ((obj->readEnd - obj->readBegin) < size)
    {
        return xkStream_VTable(stream)->VReadSomeImpl(stream, buffer, size, size, kNULL);
    }
    
    kMemCopy(buffer, &obj->readBuffer[obj->readBegin], size); 
    obj->readBegin += size; 

    return kOK;   
}

kInlineFx(kStatus) kStream_ReadSome(kStream stream, void* buffer, kSize minCount, kSize maxCount, kSize* bytesRead)
{
    kObj(kStream, stream); 
    kSize bufferAvailable = obj->readEnd - obj->readBegin; 

    if (bufferAvailable < minCount)
    {
        return xkStream_VTable(stream)->VReadSomeImpl(stream, buffer, minCount, maxCount, bytesRead);
    }
    else
    {
        kSize size = kMin_(bufferAvailable, maxCount);

        kMemCopy(buffer, &obj->readBuffer[obj->readBegin], size); 
        obj->readBegin += size; 

        if (!kIsNull(bytesRead))
        {
            *bytesRead = size; 
        }
    }

    return kOK;   
}

kInlineFx(kStatus) kStream_Write(kStream stream, const void* buffer, kSize size)
{
    kObj(kStream, stream); 

    if ((obj->writeEnd - obj->writeBegin) < size)
    {
        return xkStream_VTable(stream)->VWriteImpl(stream, buffer, size); 
    }

    kMemCopy(&obj->writeBuffer[obj->writeBegin], buffer, size); 
    obj->writeBegin += size; 

    return kOK; 
}

kInlineFx(kStatus) kStream_Copy(kStream stream, kStream source, kSize size)
{
    return kStream_CopyEx(stream, source, size, kNULL, kNULL); 
}

kFx(kStatus) kStream_CopyEx(kStream stream, kStream source, kSize size, kCallbackFx progress, kPointer context); 

kFx(kStatus) kStream_CopyAll(kStream stream, kStream source);

kInlineFx(kStatus) kStream_Seek(kStream stream, k64s offset, kSeekOrigin origin)
{
    return xkStream_VTable(stream)->VSeek(stream, offset, origin); 
}

kInlineFx(kStatus) kStream_Flush(kStream stream)
{
    return xkStream_VTable(stream)->VFlush(stream); 
}

kInlineFx(kStatus) kStream_Fill(kStream stream)
{
    kObj(kStream, stream); 

    kCheckState(!kIsNull(obj->readBuffer));

    if ((obj->readEnd - obj->readBegin) > 0)
    {
        return kOK; 
    }
    
    return xkStream_VTable(stream)->VFill(stream); 
}

kInlineFx(k64u) kStream_BytesRead(kStream stream)
{
    kObj(kStream, stream); 

    return obj->bytesRead - (k64u)(obj->readEnd - obj->readBegin); 
}

kInlineFx(k64u) kStream_BytesWritten(kStream stream)
{
    kObj(kStream, stream); 

    return obj->bytesWritten + (k64u)obj->writeBegin; 
}

kInlineFx(kStatus) kStream_ClearStats(kStream stream)
{
    kObj(kStream, stream); 

    obj->bytesRead = 0; 
    obj->bytesWritten = 0; 

    return kOK; 
}

/*
* Protected
*/

kInlineFx(kStatus) kStream_Init(kStream stream, kType type, kAlloc allocator)
{
    kCheck(kObject_Init(stream, type, allocator)); 

    kInitFields(kStream, stream); 

    return kOK; 
}

kInlineFx(kStatus) kStream_VRelease(kStream stream)
{
    return kObject_VRelease(stream);
}

kInlineFx(kStatus) kStream_VReadSomeImpl(kStream stream, void* buffer, kSize minCount, kSize maxCount, kSize* bytesRead)
{
    //legacy support: for classes that haven't been updated to implement VReadSomeImpl, 
    //try VReadImpl instead (deprecated, but still in the vtable)
    kCheck(xkStream_VTable(stream)->VReadImpl(stream, buffer, minCount)); 
    
    if (!kIsNull(bytesRead))
    {
        *bytesRead = minCount; 
    }

    return kOK; 
}

kInlineFx(kStatus) kStream_VWriteImpl(kStream stream, const void* buffer, kSize size)
{
    return kERROR_UNIMPLEMENTED; 
}

kInlineFx(kStatus) kStream_VSeek(kStream stream, k64s offset, kSeekOrigin origin)
{
    return kERROR_UNIMPLEMENTED; 
}

kInlineFx(kStatus) kStream_VFlush(kStream stream)
{
    return kOK; 
}

kInlineFx(kStatus) kStream_VFill(kStream stream)
{
    return kERROR_UNIMPLEMENTED;
}

#endif