Slic3r::NetworkAgentFactory Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/NetworkAgentFactory.hpp>

Static Public Member Functions
static void	register_all_agents ()
static bool	register_printer_agent (const std::string &id, const std::string &display_name, PrinterAgentFactory factory)
static bool	is_printer_agent_registered (const std::string &id)
static const PrinterAgentInfo *	get_printer_agent_info (const std::string &id)
static std::string	get_printer_agent_plugin_identifier (const std::string &id)
static std::vector< PrinterAgentInfo >	get_registered_printer_agents ()
static std::shared_ptr< IPrinterAgent >	create_printer_agent_by_id (const std::string &id, std::shared_ptr< ICloudServiceAgent > cloud_agent, const std::string &log_dir)
static void	clear_printer_agent_cache ()
static std::shared_ptr< ICloudServiceAgent >	create_cloud_agent (const std::string &provider, const std::string &log_dir)
static void	register_python_plugin (const std::string &plugin_key)
static void	deregister_python_plugin (const std::string &plugin_key)
static void	register_python_printer_agent (const std::string &plugin_key, const std::string &capability_name)
static void	deregister_python_printer_agent (const std::string &plugin_key, const std::string &capability_name)

Private Member Functions
	NetworkAgentFactory ()=delete
	~NetworkAgentFactory ()=delete
	NetworkAgentFactory (const NetworkAgentFactory &)=delete
NetworkAgentFactory &	operator= (const NetworkAgentFactory &)=delete

Detailed Description

NetworkAgentFactory - Factory for creating network agent instances

This factory creates cloud agents and printer agents for the networking subsystem. The architecture separates cloud services (authentication, project sync) from printer communication (device discovery, print jobs).

Startup flow:

1. Call register_all_agents() during app initialization
2. Cloud agent created at startup via create_agent_from_config()
3. Printer agent created on-demand when a printer is selected

Usage: // At app startup (before any agent creation) NetworkAgentFactory::register_all_agents();

// Create NetworkAgent with cloud agent only auto agent = create_agent_from_config(log_dir, app_config);

// When printer is selected - create printer agent from registry auto printer = NetworkAgentFactory::create_printer_agent_by_id("orca", cloud, log_dir);

Constructor & Destructor Documentation

NetworkAgentFactory() [1/2]

Slic3r::NetworkAgentFactory::NetworkAgentFactory ( )

privatedelete

Referenced by NetworkAgentFactory(), and operator=().

Here is the caller graph for this function:

~NetworkAgentFactory()

Slic3r::NetworkAgentFactory::~NetworkAgentFactory ( )

privatedelete

NetworkAgentFactory() [2/2]

Slic3r::NetworkAgentFactory::NetworkAgentFactory ( const NetworkAgentFactory & )

privatedelete

References NetworkAgentFactory().

Here is the call graph for this function:

Member Function Documentation

clear_printer_agent_cache()

void Slic3r::NetworkAgentFactory::clear_printer_agent_cache ( )

static

Clear the printer agent cache. Calls disconnect_printer() on each cached agent and releases all shared_ptrs. Should be called during application shutdown before destroying the NetworkAgent.

{
    // Disconnects and destroys the agents outside the lock, since a destructor waits for its agent's threads
    std::map<std::string, std::shared_ptr<IPrinterAgent>> cache;
    {
        std::lock_guard<std::mutex> lock(s_registry_mutex);
        cache.swap(get_printer_agent_cache());
    }
    for (auto& pair : cache) {
        if (pair.second)
            pair.second->disconnect_printer();
    }
    cache.clear();
    BOOST_LOG_TRIVIAL(info) << "Printer agent cache cleared";
}

Referenced by Slic3r::GUI::GUI_App::~GUI_App(), Slic3r::GUI::GUI_App::OnExit(), and Slic3r::GUI::GUI_App::shutdown().

Here is the caller graph for this function:

create_cloud_agent()

std::shared_ptr< ICloudServiceAgent > Slic3r::NetworkAgentFactory::create_cloud_agent ( const std::string & provider, const std::string & log_dir )

inlinestatic

Create a cloud service agent based on provider type. Handles authentication, project sync, and other cloud services.

Parameters

provider	Which implementation to use (Orca or BBL)
log_dir	Directory for log files

Returns

Shared pointer to ICloudServiceAgent implementation

    {
        if (provider == ORCA_CLOUD_PROVIDER) {
            return std::make_shared<OrcaCloudServiceAgent>(log_dir);
        } else if (provider == BBL_CLOUD_PROVIDER) {
            auto& plugin = BBLNetworkPlugin::instance();
            if (!plugin.is_loaded()) {
                return nullptr;
            }
            if (!plugin.has_agent()) {
                plugin.create_agent(log_dir);
            }
            if (!plugin.has_agent()) {
                return nullptr;
            }
            return std::make_shared<BBLCloudServiceAgent>();
        }
        return nullptr;
    }

References Slic3r::BBL_CLOUD_PROVIDER(), Slic3r::BBLNetworkPlugin::instance(), and Slic3r::ORCA_CLOUD_PROVIDER().

Referenced by Slic3r::create_agent_from_config().

Here is the call graph for this function:

Here is the caller graph for this function:

create_printer_agent_by_id()

std::shared_ptr< IPrinterAgent > Slic3r::NetworkAgentFactory::create_printer_agent_by_id ( const std::string & id, std::shared_ptr< ICloudServiceAgent > cloud_agent, const std::string & log_dir )

static

Create a printer agent by registry/config key

Returns a cached instance if one exists for the given key, otherwise creates a new agent via the registered factory and caches it.

Parameters

id	Agent registry/config key to create
cloud_agent	Cloud agent for token access
log_dir	Directory for log files

Returns

Shared pointer to IPrinterAgent, or nullptr if ID not found

{
    std::lock_guard<std::mutex> lock(s_registry_mutex);
 
    // Check cache first
    auto& cache   = get_printer_agent_cache();
    auto cache_it = cache.find(id);
    if (cache_it != cache.end()) {
        BOOST_LOG_TRIVIAL(info) << "Reusing cached printer agent: " << id;
        if (cloud_agent)
            cache_it->second->set_cloud_agent(cloud_agent);
        return cache_it->second;
    }
 
    // Not cached — create via factory
    auto& agents = get_printer_agents();
    auto it      = agents.find(id);
 
    if (it == agents.end()) {
        BOOST_LOG_TRIVIAL(warning) << "Unknown printer agent ID: " << id;
        return nullptr;
    }
 
    auto agent = it->second.factory(cloud_agent, log_dir);
    if (agent) {
        BOOST_LOG_TRIVIAL(info) << "Created and cached printer agent: " << id;
        cache[id] = agent;
    }
    return agent;
}

Referenced by Slic3r::GUI::GUI_App::switch_printer_agent().

Here is the caller graph for this function:

deregister_python_plugin()

void Slic3r::NetworkAgentFactory::deregister_python_plugin ( const std::string & plugin_key )

static

{
    std::vector<std::string> capability_names;
 
    {
        std::lock_guard<std::mutex> lock(s_registry_mutex);
        for (const auto& [capability_key, token] : s_python_printer_agent_registration_tokens) {
            (void) token;
            if (capability_key.first == plugin_key)
                capability_names.push_back(capability_key.second);
        }
        for (const auto& [capability_key, agent_id] : get_python_printer_agent_ids()) {
            (void) agent_id;
            if (capability_key.first == plugin_key &&
                std::find(capability_names.begin(), capability_names.end(), capability_key.second) == capability_names.end())
                capability_names.push_back(capability_key.second);
        }
    }
 
    for (const std::string& capability_name : capability_names)
        deregister_python_printer_agent(plugin_key, capability_name);
 
    if (capability_names.empty())
        BOOST_LOG_TRIVIAL(debug) << "Python printer-agent plugin '" << plugin_key << "' has no registered capabilities";
}

References deregister_python_printer_agent().

Referenced by Slic3r::GUI::GUI_App::init_plugin_gui_wiring().

Here is the call graph for this function:

Here is the caller graph for this function:

deregister_python_printer_agent()

void Slic3r::NetworkAgentFactory::deregister_python_printer_agent ( const std::string & plugin_key, const std::string & capability_name )

static

{
    std::string agent_id;
    std::shared_ptr<IPrinterAgent> cached_agent;
 
    {
        std::lock_guard<std::mutex> lock(s_registry_mutex);
 
        auto token_it = std::find_if(s_python_printer_agent_registration_tokens.begin(),
                                     s_python_printer_agent_registration_tokens.end(),
                                     [&plugin_key, &capability_name](const auto& entry) {
                                         return entry.first.first == plugin_key &&
                                                entry.first.second == capability_name;
                                     });
        if (token_it != s_python_printer_agent_registration_tokens.end())
            s_python_printer_agent_registration_tokens.erase(token_it);
 
        auto& python_agent_ids = get_python_printer_agent_ids();
        auto id_it = std::find_if(python_agent_ids.begin(), python_agent_ids.end(),
                                  [&plugin_key, &capability_name](const auto& entry) {
                                      return entry.first.first == plugin_key &&
                                             entry.first.second == capability_name;
                                  });
        if (id_it == python_agent_ids.end()) {
            BOOST_LOG_TRIVIAL(debug) << "Python printer-agent capability '" << capability_name << "' from plugin '"
                                     << plugin_key << "' is not registered";
            return;
        }
 
        agent_id = id_it->second;
        python_agent_ids.erase(id_it);
 
        auto& cache = get_printer_agent_cache();
        auto cache_it = cache.find(agent_id);
        if (cache_it != cache.end()) {
            cached_agent = std::move(cache_it->second);
            cache.erase(cache_it);
        }
 
        get_printer_agents().erase(agent_id);
    }
 
    if (cached_agent)
        cached_agent->disconnect_printer();
 
    // The GUI may still own the active capability separately from the factory cache. Clear that
    // handle before the plugin module is torn down, otherwise NetworkAgent can retain a Python
    // object whose implementation is about to be unloaded.
    if (!agent_id.empty() && wxTheApp) {
        NetworkAgent* network_agent = GUI::wxGetApp().getAgent();
        if (network_agent) {
            const auto active_agent = network_agent->get_printer_agent();
            if (active_agent && active_agent->get_agent_info().id == agent_id)
                network_agent->set_printer_agent(nullptr);
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << "Deregistered Python printer-agent capability '" << capability_name << "' from plugin '"
                            << plugin_key << "' with agent ID '" << agent_id << "'";
}

References Slic3r::NetworkAgent::get_printer_agent(), and Slic3r::NetworkAgent::set_printer_agent().

Referenced by deregister_python_plugin(), and Slic3r::GUI::GUI_App::init_plugin_gui_wiring().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printer_agent_info()

const PrinterAgentInfo * Slic3r::NetworkAgentFactory::get_printer_agent_info ( const std::string & id )

static

Get info about a registered agent by registry/config key

{
    std::lock_guard<std::mutex> lock(s_registry_mutex);
    auto& agents = get_printer_agents();
    auto it      = agents.find(id);
    return (it != agents.end()) ? &it->second : nullptr;
}

Referenced by Slic3r::GUI::GUI_App::switch_printer_agent(), and Slic3r::GUI::GUI_App::switch_printer_agent_if_pending().

Here is the caller graph for this function:

get_printer_agent_plugin_identifier()

std::string Slic3r::NetworkAgentFactory::get_printer_agent_plugin_identifier ( const std::string & id )

static

Return the full plugin reference for a plugin-backed printer agent ID, or empty for built-ins.

{
    std::lock_guard<std::mutex> lock(s_registry_mutex);
    auto& agents = get_printer_agents();
    auto it      = agents.find(id);
    return (it != agents.end() && it->second.is_plugin()) ? it->second.plugin_identifier : std::string();
}

get_registered_printer_agents()

std::vector< PrinterAgentInfo > Slic3r::NetworkAgentFactory::get_registered_printer_agents ( )

static

Get all registered printer agents (for UI population)

{
    std::lock_guard<std::mutex> lock(s_registry_mutex);
    auto& agents = get_printer_agents();
    std::vector<PrinterAgentInfo> result;
    result.reserve(agents.size());
 
    for (const auto& pair : agents) {
        if (!pair.second.is_plugin())
            result.push_back(pair.second);
    }
 
    for (const auto& pair : agents) {
        if (pair.second.is_plugin())
            result.push_back(pair.second);
    }
 
    return result;
}

Referenced by Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::TabPrinter::refresh_printer_agent_dropdown(), and Slic3r::GUI::PrinterAgentChoice::reload_rows().

Here is the caller graph for this function:

is_printer_agent_registered()

bool Slic3r::NetworkAgentFactory::is_printer_agent_registered ( const std::string & id )

static

Check if an agent registry/config key is registered

{
    std::lock_guard<std::mutex> lock(s_registry_mutex);
    auto& agents = get_printer_agents();
    return agents.find(id) != agents.end();
}

operator=()

NetworkAgentFactory & Slic3r::NetworkAgentFactory::operator= ( const NetworkAgentFactory & )

privatedelete

References NetworkAgentFactory().

Here is the call graph for this function:

register_all_agents()

void Slic3r::NetworkAgentFactory::register_all_agents ( )

static

Register all built-in printer agents. Must be called once during application initialization, before any calls to get_registered_printer_agents() or create_printer_agent_by_id().

{
    register_agent<OrcaPrinterAgent>();
    register_agent<QidiPrinterAgent>();
    register_agent<SnapmakerPrinterAgent>();
    register_agent<CrealityPrintAgent>();  // Must come BEFORE MoonrakerPrinterAgent —
                                            // CrealityPrintAgent extends Moonraker behaviour
                                            // for K-series boards with CFS support.
    register_agent<MoonrakerPrinterAgent>();
 
    // Keep BBL as a built-in option. Python printer-agent plugins with the
    // same AgentInfo ID are listed separately under the plugin registry key.
    {
        auto info = BBLPrinterAgent::get_agent_info_static();
        register_printer_agent(info.id, info.name,
                               [](std::shared_ptr<ICloudServiceAgent> cloud_agent,
                                  const std::string& /*log_dir*/) -> std::shared_ptr<IPrinterAgent> {
                                   auto agent = std::make_shared<BBLPrinterAgent>();
                                   if (cloud_agent)
                                       agent->set_cloud_agent(cloud_agent);
                                   return agent;
                               });
    }
}

References Slic3r::BBLPrinterAgent::get_agent_info_static(), and register_printer_agent().

Referenced by Slic3r::GUI::GUI_App::on_init_network().

Here is the call graph for this function:

Here is the caller graph for this function:

register_printer_agent()

bool Slic3r::NetworkAgentFactory::register_printer_agent ( const std::string & id, const std::string & display_name, PrinterAgentFactory factory )

static

Register a printer agent type

Parameters

id	Unique identifier for the agent (e.g., "orca", "bbl")
display_name	Human-readable name for UI
factory	Factory function to create the agent

Returns

true if registration succeeded, false if already registered

{
    std::lock_guard<std::mutex> lock(s_registry_mutex);
    auto& agents = get_printer_agents();
    return agents.emplace(id, PrinterAgentInfo(id, display_name, std::move(factory))).second;
}

Referenced by Slic3r::anonymous_namespace{NetworkAgentFactory.cpp}::register_agent(), and register_all_agents().

Here is the caller graph for this function:

register_python_plugin()

void Slic3r::NetworkAgentFactory::register_python_plugin ( const std::string & plugin_key )

static

{
    for (const auto& capability : PluginManager::instance().get_plugin_capabilities(plugin_key, PluginCapabilityType::PrinterConnection,
                                                                                   /*only_enabled=*/true))
        register_python_printer_agent(plugin_key, capability->name());
}

References Slic3r::PluginManager::instance(), Slic3r::PrinterConnection, and register_python_printer_agent().

Referenced by Slic3r::GUI::GUI_App::init_plugin_gui_wiring().

Here is the call graph for this function:

Here is the caller graph for this function:

register_python_printer_agent()

void Slic3r::NetworkAgentFactory::register_python_printer_agent ( const std::string & plugin_key, const std::string & capability_name )

static

{
    PluginManager& plugin_manager = PluginManager::instance();
 
    auto cap = plugin_manager.get_plugin_capability({PluginCapabilityType::PrinterConnection, capability_name, plugin_key},
                                                    /*only_enabled=*/false);
    if (!cap) {
        BOOST_LOG_TRIVIAL(warning) << "Printer-agent capability '" << capability_name << "' not found for plugin '" << plugin_key << "'";
        return;
    }
 
    PluginDescriptor descriptor;
    if (!plugin_manager.try_get_plugin_descriptor(plugin_key, descriptor)) {
        BOOST_LOG_TRIVIAL(warning) << "Could not find descriptor for plugin key: '" << plugin_key;
        return;
    }
    if (!cap->is_enabled()) {
        BOOST_LOG_TRIVIAL(warning) << "Printer-agent capability '" << capability_name << "' is disabled for plugin '" << plugin_key << "'";
        return;
    }
 
    auto plugin = std::dynamic_pointer_cast<PrinterAgentPluginCapability>(cap);
 
    if (!plugin) {
        BOOST_LOG_TRIVIAL(warning) << "Loaded plugin capability '" << capability_name << "' is not a printer-agent plugin";
        return;
    }
 
    auto info = plugin->get_agent_info();
 
    if (info.id.empty()) {
        BOOST_LOG_TRIVIAL(warning) << "Printer-agent plugin '" << capability_name << "' returned an empty agent ID";
        return;
    }
 
    const auto capability_key = std::make_pair(plugin_key, capability_name);
    std::shared_ptr<PythonPrinterAgentRegistrationToken> registration_token;
    {
        std::lock_guard<std::mutex> lock(s_registry_mutex);
        auto token_it = std::find_if(s_python_printer_agent_registration_tokens.begin(), s_python_printer_agent_registration_tokens.end(),
                                     [&plugin_key, &capability_name](const auto& entry) {
                                         return entry.first.first == plugin_key && entry.first.second == capability_name;
                                     });
        if (token_it == s_python_printer_agent_registration_tokens.end()) {
            registration_token = std::make_shared<PythonPrinterAgentRegistrationToken>();
            s_python_printer_agent_registration_tokens.emplace(capability_key, registration_token);
        } else {
            registration_token = token_it->second;
        }
    }
 
    const std::string plugin_full_ref = plugin_printer_agent_full_ref(descriptor, capability_name);
 
    std::weak_ptr<PrinterAgentPluginCapability> weak_plugin = plugin;
    PrinterAgentFactory factory                             = [weak_plugin](std::shared_ptr<ICloudServiceAgent> cloud_agent,
                                                const std::string& /*log_dir*/) -> std::shared_ptr<IPrinterAgent> {
        // The capability implements IPrinterAgent directly, so it is handed out as the
        // live agent (no adapter); the Python plugin services the calls.
        auto plugin = weak_plugin.lock();
        if (!plugin)
            return nullptr;
 
        if (cloud_agent)
            plugin->set_cloud_agent(cloud_agent);
        return plugin;
    };
 
    // Python work above may allow disable/unload/reload to replace this capability.
    // Re-resolve without holding the registry mutex to avoid lock inversion and reentrancy.
    // only_enabled defaults to true here, so a capability that changed identity (reload) or was
    // merely disabled both surface the same way: current_cap no longer equals cap.
    auto current_cap = plugin_manager.get_plugin_capability({PluginCapabilityType::PrinterConnection, capability_name, plugin_key});
    if (current_cap != cap) {
        BOOST_LOG_TRIVIAL(debug) << "Printer-agent capability '" << capability_name << "' from plugin '" << plugin_key
                                 << "' changed or was disabled during registration";
        return;
    }
 
    std::shared_ptr<IPrinterAgent> cached_agent;
 
    auto reject_conflicting_capability = [plugin_key, capability_name](const std::string& error_message) {
        if (!wxTheApp || GUI::wxGetApp().is_closing())
            return;
        GUI::wxGetApp().CallAfter([plugin_key, capability_name, error_message]() {
            if (GUI::wxGetApp().is_closing())
                return;
            PluginManager& manager = PluginManager::instance();
            manager.set_plugin_error(plugin_key, error_message);
            // note: the unload callback triggered by disabling will call deregister,
            // which will be a no-op since the printer agent is never registered
            manager.set_capability_enabled({PluginCapabilityType::PrinterConnection, capability_name, plugin_key}, false);
            wxMessageBox(wxString::FromUTF8(error_message.c_str()), _L("Plugins"), wxOK | wxICON_WARNING, GUI::wxGetApp().GetTopWindow());
        });
    };
 
    {
        std::lock_guard<std::mutex> lock(s_registry_mutex);
 
        auto token_it = std::find_if(s_python_printer_agent_registration_tokens.begin(), s_python_printer_agent_registration_tokens.end(),
                                     [&plugin_key, &capability_name](const auto& entry) {
                                         return entry.first.first == plugin_key && entry.first.second == capability_name;
                                     });
        const bool cap_still_enabled = cap->is_enabled();
        if (token_it == s_python_printer_agent_registration_tokens.end() || token_it->second != registration_token ||
            !cap_still_enabled) {
            BOOST_LOG_TRIVIAL(debug) << "Printer-agent capability '" << capability_name << "' from plugin '" << plugin_key
                                     << "' was disabled before registry commit";
            return;
        }
 
        auto& python_agent_ids = get_python_printer_agent_ids();
        for (const auto& pair : python_agent_ids) {
            if (pair.first != capability_key && pair.second == info.id) {
                const std::string error_message = GUI::format(
                    // TRN %1% is the printer agent name, %2% its ID, %3% the capability and %4% the plugin already using that ID.
                    _u8L("Printer-agent '%1%' could not be enabled: agent ID '%2%' is already registered by capability '%3%' from plugin '%4%'."),
                    info.name, info.id, pair.first.second, pair.first.first);
                BOOST_LOG_TRIVIAL(warning) << error_message;
                reject_conflicting_capability(error_message);
                return;
            }
        }
 
        auto plugin_it = python_agent_ids.find(capability_key);
        if (plugin_it != python_agent_ids.end() && plugin_it->second != info.id) {
            const std::string old_agent_id = plugin_it->second;
            get_printer_agents().erase(old_agent_id);
 
            auto& cache   = get_printer_agent_cache();
            auto cache_it = cache.find(old_agent_id);
            if (cache_it != cache.end()) {
                cached_agent = std::move(cache_it->second);
                cache.erase(cache_it);
            }
        }
 
        auto& agents = get_printer_agents();
        auto agent_it = agents.find(info.id);
        // why: reject only when the ID is owned by SOMEONE ELSE - a built-in has an empty
        //   plugin_identifier, another plugin/capability has a different plugin_full_ref. When it
        //   IS the same plugin_full_ref, this capability is just re-registering itself, so fall
        //   through and refresh.
        if (agent_it != agents.end() && agent_it->second.plugin_identifier != plugin_full_ref) {
            const std::string error_message = GUI::format(
                // TRN %1% is the printer agent name, %2% its ID and %3% the printer agent already using that ID.
                _u8L("Printer-agent '%1%' could not be enabled: agent ID '%2%' is already registered by '%3%'."),
                info.name, info.id, agent_it->second.display_name);
            BOOST_LOG_TRIVIAL(warning) << error_message;
            reject_conflicting_capability(error_message);
            return;
        }
 
        // why: insert_or_assign, not emplace - reaching here means the ID is new, or the same
        //   capability is re-registering (same plugin_full_ref). In the re-register case we WANT to
        //   overwrite so the factory closure points at the current live capability instance; emplace
        //   would silently keep the stale entry.
        agents.insert_or_assign(info.id, PrinterAgentInfo(info.id, info.name, plugin_full_ref, std::move(factory)));
        python_agent_ids[capability_key] = info.id;
 
        auto& cache   = get_printer_agent_cache();
        auto cache_it = cache.find(info.id);
        if (cache_it != cache.end()) {
            cached_agent = std::move(cache_it->second);
            cache.erase(cache_it);
        }
    }
 
    if (cached_agent)
        cached_agent->disconnect_printer();
 
    BOOST_LOG_TRIVIAL(info) << "Registered printer-agent plugin '" << capability_name << "' with agent ID '" << info.id
                            << "' and plugin ref '" << plugin_full_ref << "'";
}

References _L, _u8L, Slic3r::GUI::format(), Slic3r::PluginManager::get_plugin_capability(), Slic3r::PluginManager::instance(), Slic3r::PrinterConnection, Slic3r::PluginManager::set_capability_enabled(), Slic3r::PluginManager::set_plugin_error(), and Slic3r::PluginManager::try_get_plugin_descriptor().

Referenced by Slic3r::GUI::GUI_App::init_plugin_gui_wiring(), and register_python_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/NetworkAgentFactory.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/NetworkAgentFactory.cpp