set_parameter()

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

void MayaFlux::Yantra::UniversalTransformer< InputType, OutputType >::set_parameter ( const std::string &  name, std::any  value  )

inlineoverridevirtual

Type-safe parameter management with transformation-specific defaults.

Parameters

name	Parameter name
value	Parameter value (type-erased)

Handles core transformer parameters (strategy, quality, scope) and delegates transformer-specific parameters to set_transformation_parameter().

Core parameters:

• "strategy": TransformationStrategy enum or string
• "quality": TransformationQuality enum or string
• "scope": TransformationScope enum or string

Implements MayaFlux::Yantra::ComputeOperation< InputType, OutputType >.

Definition at line 247 of file UniversalTransformer.hpp.

    {
        if (name == "strategy") {
            auto strategy_result = safe_any_cast<TransformationStrategy>(value);
            if (strategy_result) {
                m_strategy = *strategy_result.value;
                return;
            }
            auto str_result = safe_any_cast<std::string>(value);
            if (str_result) {
                auto strategy_enum = Reflect::string_to_enum_case_insensitive<TransformationStrategy>(*str_result.value);
                if (strategy_enum) {
                    m_strategy = *strategy_enum;
                    return;
                }
            }
        }
        if (name == "quality") {
            auto quality_result = safe_any_cast<TransformationQuality>(value);
            if (quality_result) {
                m_quality = *quality_result.value;
                return;
            }
            auto str_result = safe_any_cast<std::string>(value);
            if (str_result) {
                auto quality_enum = Reflect::string_to_enum_case_insensitive<TransformationQuality>(*str_result.value);
                if (quality_enum) {
                    m_quality = *quality_enum;
                    return;
                }
            }
        }
        if (name == "scope") {
            auto scope_result = safe_any_cast<TransformationScope>(value);
            if (scope_result) {
                m_scope = *scope_result.value;
                return;
            }
            auto str_result = safe_any_cast<std::string>(value);
            if (str_result) {
                auto scope_enum = Reflect::string_to_enum_case_insensitive<TransformationScope>(*str_result.value);
                if (scope_enum) {
                    m_scope = *scope_enum;
                    return;
                }
            }
        }
        set_transformation_parameter(name, std::move(value));
    }