Slic3r::anonymous_namespace{PluginResolver.cpp} Namespace Reference

Functions
std::string	find_option_for_capability (Preset::Type type, const Preset &preset, const PluginCapabilityRef &ref, PluginCapabilityType capability_type=PluginCapabilityType::Unknown)
void	collect_capabilities_in_use (Preset::Type type, const Preset &preset, std::vector< PluginCapabilityId > &out)

Function Documentation

collect_capabilities_in_use()

void Slic3r::anonymous_namespace{PluginResolver.cpp}::collect_capabilities_in_use	(	Preset::Type	type,
		const Preset &	preset,
		std::vector< PluginCapabilityId > &	out )

{
    for (const PluginCapabilityRef& ref : referenced_capabilities(type, preset)) {
        // Cloud plugins resolve by UUID, local plugins by plugin_key.
        const std::string key = ref.uuid.empty() ? ref.name : ref.uuid;
        if (key.empty())
            continue;
 
        PluginDescriptor descriptor;
        if (!PluginManager::instance().try_get_plugin_descriptor(key, descriptor))
            continue;
 
        // The manifest ref does not carry a type, so require the live capability type to match the
        // type declared by the option that references it.
        for (const auto& capability : PluginManager::instance().get_plugin_capabilities(descriptor.plugin_key, PluginCapabilityType::Unknown, false))
            if (capability && capability->type() != PluginCapabilityType::Unknown &&
                capability->name() == ref.capability_name &&
                !find_option_for_capability(type, preset, ref, capability->type()).empty())
                out.push_back(capability->identity());
    }
}

References collect_capabilities_in_use(), find_option_for_capability(), Slic3r::PluginManager::instance(), Slic3r::PluginDescriptor::plugin_key, Slic3r::referenced_capabilities(), Slic3r::Preset::type, and Slic3r::Unknown.

Referenced by collect_capabilities_in_use().

Here is the call graph for this function:

Here is the caller graph for this function:

find_option_for_capability()

std::string Slic3r::anonymous_namespace{PluginResolver.cpp}::find_option_for_capability	(	Preset::Type	type,
		const Preset &	preset,
		const PluginCapabilityRef &	ref,
		PluginCapabilityType	capability_type = PluginCapabilityType::Unknown )

{
    if (type != Preset::TYPE_PRINT && type != Preset::TYPE_PRINTER && type != Preset::TYPE_FILAMENT)
        return {};
 
    // Options opt in via ConfigOptionDef::is_plugin_backed, so scan the definition rather than keep a
    // hardcoded per-type field list. A typed preset's config only holds keys for its own type.
    const ConfigDef* def = preset.config.def();
    if (def == nullptr)
        return {};
 
    const std::string expected_type = plugin_capability_type_to_string(capability_type);
    const auto matches_ref = [&ref](const std::string& value) {
        return value == ref.capability_name;
    };
 
    for (const std::string& field : preset.config.keys()) {
        const ConfigOptionDef* opt_def = def->get(field);
        if (opt_def == nullptr || !opt_def->is_plugin_backed() ||
            (capability_type != PluginCapabilityType::Unknown && opt_def->plugin_type != expected_type))
            continue;
 
        const ConfigOption* option = preset.config.option(field);
        if (option == nullptr)
            continue;
 
        if (const auto* string_option = dynamic_cast<const ConfigOptionString*>(option)) {
            if (string_option->value == ref.capability_name)
                return field;
            continue;
        }
 
        if (const auto* vector_option = dynamic_cast<const ConfigOptionVectorBase*>(option)) {
            const std::vector<std::string> values = vector_option->vserialize();
            if (std::any_of(values.begin(), values.end(), matches_ref))
                return field;
        }
    }
 
    // printer_agent stores AgentInfo::id, so a missing plugin cannot be reverse-mapped through
    // the runtime registry. If no regular printer plugin field matched, assume printer_agent.
    if (type == Preset::Type::TYPE_PRINTER && preset.config.has("printer_agent")) {
        const ConfigOptionDef* agent_def = def->get("printer_agent");
        if (agent_def != nullptr && agent_def->is_plugin_backed() &&
            (capability_type == PluginCapabilityType::Unknown || agent_def->plugin_type == expected_type))
        return "printer_agent";
    }
 
    return {};
}

References Slic3r::PluginCapabilityRef::capability_name, Slic3r::Preset::config, Slic3r::DynamicPrintConfig::def(), find_option_for_capability(), Slic3r::ConfigDef::get(), Slic3r::ConfigOptionResolver::has(), Slic3r::ConfigOptionDef::is_plugin_backed(), Slic3r::DynamicConfig::keys(), Slic3r::ConfigBase::option(), Slic3r::plugin_capability_type_to_string(), Slic3r::ConfigOptionDef::plugin_type, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::Unknown.

Referenced by collect_capabilities_in_use(), and find_option_for_capability().

Here is the call graph for this function:

Here is the caller graph for this function: