element gets passed along the chain, but it is managable. The advantage is that you have zero heap overhead by not recreating the chain after every use.
Early stage of development. I am currently rewriting my software to find a good interface solution by checking if I am comfortable with the current design.
Schema description has been rewritten once already and the current version is probably here to stay. The default container will be changed in the future, so
no parsing will be necessary with my binary format.
This class is the builder class responsible for creating new nodes in the directed processing graph created by it. It is also the owner of the outbound points of the chain.
Most of the times this async relationship graph is started by using ```newConveyorAndFeeder``` which returns a connected input and output
class. Type safety is guaranteed since the input and output classes are fully templated.
For processing to be able to happen it is necessary to create an ```EventLoop``` instance and activate it on the current thread by creating a ```WaitScope``` class before using the
You can create your async context by calling ```setupAsyncIo()``` which creates this OS dependent ```EventPort``` as well as an ```EventLoop``` and some other network related features for you.
Most of the times you want to create the ```AsyncIoContext``` on the main thread while in the future other threads can or should have a custom implementation
of ```EventPort``` to allow for external events arriving for these threads as well. In the context of threads external means outside of the mentioned thread.
Cross-Thread communication currently is implemented by external means due to missing features. It is done either by implementing your own thread-safe data