AuroraRuntime/Source/IO/Utility/AuIOBufferedProcessor.cpp
Jamie Reece Wilson 635f9e39e9 [*] Modernize IOBufferedProcessor (and moved to the io utility namespace)
[+] AuIO::Utility::NewBufferedProcessorEx
[+] AuByteBuffer::calcDifferenceBetweenHeadsUnsigned
[+] AuByteBuffer::calcDifferenceBetweenHeadsSigned
2023-09-28 12:38:01 +01:00

177 lines
6.0 KiB
C++

/***
Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.
File: AuIOBufferedProcessor.cpp
Date: 2022-6-6
Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include <Aurora/IO/IOExperimental.hpp>
#include "AuIOBufferedProcessor.hpp"
namespace Aurora::IO::Utility
{
struct IOBufferedProcessor :
IIOBufferedProcessor,
AuEnableSharedFromThis<IOBufferedProcessor>
{
AuSPtr<IStreamReader> pSource;
AuSPtr<IStreamWriter> pDrain;
AuSPtr<IIOPipeInterceptor> pProcessor;
AuSPtr<Protocol::IProtocolInterceptorEx> pProcessorEx;
AuUInt32 uBufferSize {};
AuByteBuffer buffer;
AuByteBuffer buffer2;
bool bErrored {};
AU_DEFINE_FOR_VA(IOBufferedProcessor,
(AU_DEFINE_CTOR_VA, // initializer-list-like ctor (extending a struct or adding a ctor will break initializer lists)
AU_DEFINE_THIS_MOVE_CTOR_VA, // add move `Object(Object &&)`
AU_DEFINE_EQUALS_VA, // add equals operator
AU_DEFINE_MOVE_VA, // add move assignment operator
AU_DEFINE_COPY_VA), // add copy assignment operator
(pSource, pDrain, pProcessor, uBufferSize));
IOBufferedProcessor(AuSPtr<IStreamReader> pSource,
AuSPtr<IStreamWriter> pDrain,
AuSPtr<Protocol::IProtocolInterceptorEx> pProcessor,
AuUInt32 uBufferSize) :
pSource(pSource),
pDrain(pDrain),
pProcessorEx(pProcessor),
uBufferSize(uBufferSize)
{
}
AuUInt32 TryProcessBuffered() override;
AuUInt32 GetRawBytesBuffered() override;
AuUInt32 GetRawBytesLimit() override;
AuUInt32 TryPump();
};
AuUInt32 IOBufferedProcessor::TryProcessBuffered()
{
if (this->buffer.IsEmpty())
{
this->buffer.Allocate(this->uBufferSize);
this->buffer.flagCircular = true;
if (this->pProcessorEx)
{
this->buffer2.Allocate(this->uBufferSize);
this->buffer2.flagCircular = true;
}
}
if (!this->buffer ||
(this->pProcessorEx && !this->buffer2))
{
return TryPump();
}
AuUInt read {};
try
{
if (this->pSource->Read(AuMemoryViewStreamWrite(AuMemoryViewWrite(this->buffer), read)) !=
AuIO::EStreamError::eErrorNone)
{
return this->TryPump();
}
}
catch (...)
{
SysPushErrorCatch();
}
this->buffer.writePtr += read;
return this->TryPump();
}
AuUInt32 IOBufferedProcessor::TryPump()
{
AuUInt uBytesProcessedTotal {};
AuUInt uBytesProcessed {};
if (this->bErrored)
{
return 0;
}
do
{
try
{
if (this->pProcessor)
{
if (!this->pProcessor->OnDataAvailable(AuMemoryViewStreamRead(AuMemoryViewRead(this->buffer), uBytesProcessed), this->pDrain))
{
break;
}
}
else if (this->pProcessorEx)
{
auto pRead = this->buffer.readPtr;
if (!this->pProcessorEx->OnDataAvailable(AuSharedPointerFromThis(&this->buffer), AuSharedPointerFromThis(&this->buffer2), {}))
{
this->buffer.readPtr = pRead;
break;
}
AuUInt uWritten {};
if (AuIO::WriteAll(this->pDrain.get(), { AuMemoryViewRead(this->buffer2), uWritten }) != AuIO::EStreamError::eErrorNone)
{
this->bErrored = true;
}
this->buffer2.readPtr += uWritten;
uBytesProcessed = this->buffer.calcDifferenceBetweenHeadsUnsigned(this->buffer.readPtr, pRead);
}
}
catch (...)
{
SysPushErrorCatch();
}
this->buffer.readPtr += uBytesProcessed;
uBytesProcessedTotal += uBytesProcessed;
}
while (AuExchange(uBytesProcessedTotal, 0));
return uBytesProcessedTotal;
}
AuUInt32 IOBufferedProcessor::GetRawBytesBuffered()
{
return this->buffer.RemainingBytes();
}
AuUInt32 IOBufferedProcessor::GetRawBytesLimit()
{
return this->uBufferSize;
}
AUKN_SYM AuSPtr<IIOBufferedProcessor> NewBufferedProcessor(const AuSPtr<IStreamReader> &pSource,
const AuSPtr<IIOPipeInterceptor> &pProcessor,
const AuSPtr<IStreamWriter> &pDrain,
AuUInt32 uBufferSize)
{
SysCheckArgNotNull(pProcessor, {});
SysCheckArgNotNull(pDrain, {});
SysCheckArgNotNull(pSource, {});
return AuMakeShared<IOBufferedProcessor>(pSource, pDrain, pProcessor, uBufferSize);
}
AUKN_SYM AuSPtr<IIOBufferedProcessor> NewBufferedProcessorEx(const AuSPtr<IStreamReader> &pSource,
const AuSPtr<Protocol::IProtocolInterceptorEx> &pProcessor,
const AuSPtr<IStreamWriter> &pDrain,
AuUInt32 uBufferSize)
{
SysCheckArgNotNull(pProcessor, {});
SysCheckArgNotNull(pDrain, {});
SysCheckArgNotNull(pSource, {});
return AuMakeShared<IOBufferedProcessor>(pSource, pDrain, pProcessor, uBufferSize);
}
}