process()

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = InputType>

output_type MayaFlux::Yantra::ComputationPipeline< InputType, OutputType >::process ( const input_type &  input, const ExecutionContext &  context = {}  )

inline

Execute the pipeline with grammar rule application.

Parameters

input	Input data to process through the pipeline
context	Execution context containing parameters and metadata

Returns

Processed output data

Executes the complete pipeline processing workflow:

1. Grammar Rule Application: Searches for grammar rules that match the input data and execution context. If a matching rule is found, applies it first.
2. Operation Chain Execution: Executes all operations in the pipeline in the order they were added, passing output from each stage as input to the next.
3. Type Conversion: Handles type conversion between InputType and OutputType when they differ.

The pipeline provides comprehensive error handling with operation-specific error messages that include the operation name for debugging.

Exceptions

std::runtime_error

If any operation in the pipeline fails

Definition at line 155 of file ComputePipeline.hpp.

                                                                                   {})
    {
        input_type current_data = input;
        ExecutionContext current_context = context;
 
        if (auto best_rule = m_grammar->find_best_match(current_data, current_context)) {
            if (auto rule_result = m_grammar->execute_rule(best_rule->name, current_data, current_context)) {
                auto cast_result = safe_any_cast<input_type>(*rule_result);
 
                if (cast_result) {
                    current_data = *cast_result.value;
                } else {
                    MF_ERROR(
                        Journal::Component::Yantra,
                        Journal::Context::Runtime,
                        "Grammar rule '{}' returned incompatible type: {}",
                        best_rule->name,
                        cast_result.error);
                }
            }
        }
 
        for (const auto& [operation, name] : m_operations) {
            try {
                auto result = operation->apply_operation(current_data);
                current_data = result;
            } catch (const std::exception& e) {
                error_rethrow(
                    Journal::Component::Yantra, Journal::Context::Runtime, std::source_location::current(),
                    "Pipeline operation '{}' failed: {}", name, e.what());
            }
        }
 
        if constexpr (std::is_same_v<InputType, OutputType>) {
            return current_data;
        } else {
            output_type result;
            return result;
        }
    }