with_async() [1/2]

template<ComputeData StartType, typename ChainFunc , typename CompleteFn >

void MayaFlux::Yantra::ComputeMatrix::with_async ( Datum< StartType >  input, ChainFunc &&  chain, CompleteFn &&  on_complete  )

inline

Execute an operation chain asynchronously.

chain receives a FluentExecutor seeded with input and must return the terminal Datum. The entire sequence runs on a background thread. on_complete is invoked with the result on that same thread.

The future is owned by this matrix instance. drain_async() and the destructor guarantee all in-flight chains finish before the matrix is destroyed. No thread management is required by the caller.

matrix->with_async(make_granular_input(container),
    [](auto chain) {
        return chain.then<SegmentOp>("segment")
                    .then<AttributeOp>("attribute")
                    .then<SortOp>("sort")
                    .to_io();
    },
    [ex](Datum<Kakshya::RegionGroup> result) {
        ex->grains = std::move(result);
        ex->ready  = true;
    });

Template Parameters

StartType	Input data type.
ChainFunc	Callable: (FluentExecutor<ComputeMatrix, StartType>) -> Datum<ResultType>.
CompleteFn	Callable: (Datum<R>) -> void, where R is deduced from ChainFunc.

Parameters

input	Seed datum for the chain.
chain	Lambda describing the full operation sequence.
on_complete	Called with the final Datum on completion.

Definition at line 401 of file ComputeMatrix.hpp.

    {
        auto self = shared_from_this();
        register_async(std::async(std::launch::async,
            [self,
                input = std::move(input),
                chain = std::forward<ChainFunc>(chain),
                on_complete = std::forward<CompleteFn>(on_complete)]() mutable {
                on_complete(chain(
                    FluentExecutor<ComputeMatrix, StartType>(self, std::move(input))));
            }));
    }