add_operation_rule()

template<typename ConcreteOpType , typename... OpArgs>

void MayaFlux::Yantra::ComputationGrammar::add_operation_rule ( const std::string &  rule_name, ComputationContext  context, UniversalMatcher::MatcherFunc  matcher, const std::unordered_map< std::string, std::any > &  op_parameters = {}, int  priority = 50, OpArgs &&...  op_args  )

inline

Helper to add concrete operation rules with automatic executor generation.

Template Parameters

ConcreteOpType	The concrete operation type to instantiate
OpArgs	Constructor argument types for the operation

Parameters

rule_name	Unique name for this rule
context	Computation context for the rule
matcher	Matcher function to determine when rule applies
op_parameters	Parameters to configure the operation instance
priority	Execution priority (default: 50)
op_args	Constructor arguments for the operation

Creates a rule that automatically instantiates and configures a concrete operation type when matched. This is the preferred way to integrate existing operations into the grammar system, as it handles type safety and parameter application automatically.

The generated executor:

1. Creates an instance of ConcreteOpType with the provided constructor arguments
2. Applies the op_parameters using set_parameter()
3. Applies additional parameters from the execution context
4. Executes the operation on the input data

Example:

grammar.add_operation_rule<SpectralTransformer<>>(
    "pitch_shift_rule",
    ComputationContext::SPECTRAL,
    UniversalMatcher::create_type_matcher<std::vector<Kakshya::DataVariant>>(),
    {{"operation", std::string("pitch_shift")}, {"pitch_ratio", 1.5}},
    80 // priority
);

Definition at line 261 of file ComputeGrammar.hpp.

                                                                   {},
        int priority = 50,
        OpArgs&&... op_args)
    {
        Rule rule;
        rule.name = rule_name;
        rule.context = context;
        rule.priority = priority;
        rule.matcher = std::move(matcher);
        rule.target_operation_type = std::type_index(typeid(ConcreteOpType));
 
        auto captured_args = std::make_tuple(std::forward<OpArgs>(op_args)...);
 
        rule.executor = [op_parameters, captured_args = std::move(captured_args)](const std::any& input, const ExecutionContext& ctx) -> std::any {
            auto operation = std::apply([&op_parameters](auto&&... args) {
                return create_configured_operation<ConcreteOpType>(op_parameters, std::forward<decltype(args)>(args)...);
            },
                captured_args);
 
            apply_context_parameters(operation, ctx);
 
            auto typed_input = safe_any_cast_or_throw<DataIO>(input);
            return operation->apply_operation(typed_input);
        };
 
        add_rule(std::move(rule));
    }