[*] Comments

This commit is contained in:
Reece Wilson 2023-04-21 05:44:23 +01:00
parent 36c163d90c
commit 4b0dfabd67
5 changed files with 20 additions and 20 deletions

View File

@ -13,10 +13,7 @@ namespace Aurora::Exit
{
Threading::Threads::IAuroraThread *pCaller;
};
/**
* @brief User definedable callback
*/
AUKN_INTERFACE(IExitSubscriber,
AUI_METHOD(void, OnTrigger, (ETriggerLevel, level, const ExitInvoker *, pInvoker))
);

View File

@ -7,6 +7,8 @@
Note: Defer to Async.hpp for creation of overlapped stream objects
This header defines FS.hpp-like APIs that run overlapped or on a
worker thread or two.
**IMPL IN PROGRESS**
***/
#pragma once
@ -49,7 +51,7 @@ namespace Aurora::IO::FS
* @brief If running under AuAsync runner, we use the local thread for the entire IO operation.
* In the future, whence I can be bothered to finish the APC api, *all* overlapped operations
* will be processed on the local thread.
* Specifying true forces all IO to occour on a preallocated pool of IO workers
* Specifying true forces all IO to occur on a preallocated pool of IO workers
* @warning this api is thread-local
* @warning this api does not change the behaviour of overlapped file streamss
*/

View File

@ -12,8 +12,9 @@ namespace Aurora::IO::Protocol
AUKN_INTERFACE(IProtocolInterceptorEx,
/**
* @brief
* @return false restores the read head, will retrieve further callbacks
* true nothing
* @return false restores the read head of pReadInByteBuffer. future callbacks will still be made.
* true nothing; pReadInByteBuffer's heads will remain set by the user and the tick is propagated down the stack.
* @warning the error flags of both bytebuffers can seize up the protocol stack by design.
*/
AUI_METHOD(bool, OnDataAvailable, (const AuSPtr<Memory::ByteBuffer> &, pReadInByteBuffer,
const AuSPtr<Memory::ByteBuffer> &, pWriteOutByteBuffer))

View File

@ -17,8 +17,7 @@ namespace Aurora::IO::Protocol
virtual void Remove() = 0;
/**
* @brief Fetches an IStreamWriter representation of the next piece
* in the stack
* @brief Fetches an IStreamWriter representation of the next piece in the stack
* @return
*/
virtual AuSPtr<IStreamWriter> ToNextWriter() = 0;

View File

@ -37,15 +37,19 @@ namespace Aurora::IO::Protocol
/**
* @brief Same as AppendInterceptor, except that DoTick will repeat until the input is fully consumed.
* This allows us to tick processors under our frame, followed by a retick if there is more data available.
* Such paradigm contrasts the default stream-specific/non-framing behaviour where the processor is
* responsible for consuming all non-segmented data (ala everything except the start of the final unfinished frame).
*
* This allows us to tick processors under our frame, followed by a retick if there is more data available to us.
* Such paradigm contrasts the default unframed/raw stream behaviour where the processor is responsible for consuming all
* available data.
* With such limitations, it's impossible to build a protocol where a piece in the middle
* 1) can/should only flush 1 frame to the next processor
* 2) reads only a portion of pReadInByteBuffer
* This function sets an internal flag that indicates re-ticks from the root are to be expected to complete
* a tick. Otherwise, the read head of the inbound frame of a persumed stream may only skip back to frame zero
* on error OR frame +1 on success. With this flag, frame current to frame end will be ticked.
* 1) can/should only flush 1 frame to the following interceptor
* (this is a problem when the frame does not contain a length prefix and the next interceptor is a frame processor)
* 2) only reads a portion of pReadInByteBuffer
* (the current interceptor can only process a frame of data per tick)
*
* This function sets an internal flag that indicates re-ticks from the root single frame processor are to be expected
* in order to complete a single ::DoTick tick. With this flag enabled, multiple tick may occur as opposed to a single
* callback per ::DoTick().
* @param pInterceptorEx
* @return
*/
@ -76,8 +80,6 @@ namespace Aurora::IO::Protocol
/**
* @brief Sends one tick down the protocol stack, regardless of how much data is written into the
* next piece/interceptor, and regardless of if another read tick is required.
* Latterly, you are responsible for consuming all available bytes in your non-framed
* (~AppendSingleFrameProcessor[Ex]) interceptors.
*/
virtual void DoTick() = 0;
@ -96,7 +98,6 @@ namespace Aurora::IO::Protocol
/**
* @brief Creates a protocol stack backed by the memory of a pipe.
* DoTick must be called each time the pipe has data.
* @param pWork
* @return
*/