process_to_container_async() [2/2]

template<typename CompleteFn >

void MayaFlux::Yantra::Granular::process_to_container_async	(	const std::shared_ptr< GranularMatrix > &	matrix,
		const std::shared_ptr< Kakshya::SignalSourceContainer > &	container,
		AttributeExecutor	executor,
		CompleteFn &&	on_complete,
		const GranularConfig &	config = {},
		GranularOutput	output = GranularOutput::CONTAINER
	)

Async offline granular pipeline (AttributeExecutor path).

Parameters

matrix	ComputeMatrix that owns the async future.
container	Source signal data.
executor	Lambda receiving grain samples and context, returning a scalar.
on_complete	Called on the worker thread with the finished container.
config	Pipeline scalar parameters.
output	CONTAINER for concatenative, CONTAINER_ADDITIVE for OLA.

Definition at line 582 of file GranularWorkflow.hpp.

                                   {},
    GranularOutput output = GranularOutput::CONTAINER)
{
    auto ctx = make_granular_context(config, std::move(executor));
 
    ctx.execution_metadata["container"] = container;
    if (config.taper)
        ctx.execution_metadata["grain_taper"] = config.taper;
 
    auto seg_op = matrix->get_operation<SegmentOp>("segment");
    auto attr_op = matrix->get_operation<AttributeOp>("attribute");
    auto sort_op = matrix->get_operation<SortOp>("sort");
    apply_context_parameters(seg_op, ctx);
    apply_context_parameters(attr_op, ctx);
    apply_context_parameters(sort_op, ctx);
 
    matrix->with_async(make_granular_input(container), [seg_op, attr_op, sort_op, ctx, output](auto chain) {
            auto sorted = chain
                .template then<SegmentOp>("segment")
                .template then<AttributeOp>("attribute")
                .template then<SortOp>("sort")
                .to_io();
            if (output == GranularOutput::CONTAINER_ADDITIVE) {
                return safe_any_cast_or_throw<
                    Datum<std::shared_ptr<Kakshya::SignalSourceContainer>>>(
                        reconstruct_grains_additive(std::any(sorted), ctx));
            }
            return safe_any_cast_or_throw<
                Datum<std::shared_ptr<Kakshya::SignalSourceContainer>>>(
                    reconstruct_grains(std::any(sorted), ctx)); }, std::forward<CompleteFn>(on_complete));
}