Slic3r::anonymous_namespace{ElegooLink.cpp} Namespace Reference

Enumerations
enum class	ElegooPrinterType { Other , CC , CC2 }

Functions
std::string	sn_cache_key (const std::string &host_ip, const std::string &token)
void	cache_sn (const std::string &host_ip, const std::string &token, const std::string &sn)
std::string	lookup_sn (const std::string &host_ip, const std::string &token)
std::string	load_sn_from_config (const std::string &host_ip)
void	persist_sn (const std::string &host_ip, const std::string &token, const std::string &sn)
ElegooPrinterType	classify_printer_model (const std::string &printer_model)
std::string	get_cc2_token (const std::string &apikey)
bool	parse_cc2_response (const std::string &body, std::string &error_message, std::string *serial_number=nullptr)
std::string	lookup_cc2_serial_impl (const std::string &printer_model, const std::string &print_host, const std::string &apikey)
std::string	lookup_cc2_serial (DynamicPrintConfig *config)
std::string	escape_string (const std::string &unescaped)
std::string	escape_path_by_element (const boost::filesystem::path &path)
std::string	path_to_utf8 (const boost::filesystem::path &path)
std::string	filename_to_utf8 (const boost::filesystem::path &path)

Variables
constexpr const char *	ELEGOO_CC2_DEFAULT_TOKEN = "123456"
constexpr const char *	ELEGOO_DEV_SN_SECTION = "dev_sn"
static std::mutex	s_sn_cache_mutex
static std::map< std::string, std::string >	s_sn_cache

Enumeration Type Documentation

ElegooPrinterType

enum class Slic3r::anonymous_namespace{ElegooLink.cpp}::ElegooPrinterType

strong

Enumerator
Other
CC
CC2

                                     {
            Other,
            CC,
            CC2,
        };

Function Documentation

cache_sn()

void Slic3r::anonymous_namespace{ElegooLink.cpp}::cache_sn	(	const std::string &	host_ip,
		const std::string &	token,
		const std::string &	sn )

        {
            if (host_ip.empty() || token.empty() || sn.empty())
                return;
            std::lock_guard<std::mutex> lock(s_sn_cache_mutex);
            s_sn_cache[sn_cache_key(host_ip, token)] = sn;
        }

References cache_sn(), s_sn_cache, s_sn_cache_mutex, and sn_cache_key().

Referenced by cache_sn(), and persist_sn().

Here is the call graph for this function:

Here is the caller graph for this function:

classify_printer_model()

ElegooPrinterType Slic3r::anonymous_namespace{ElegooLink.cpp}::classify_printer_model

(

const std::string &

printer_model

)

        {
            if (!boost::algorithm::starts_with(printer_model, "Elegoo Centauri"))
                return ElegooPrinterType::Other;
 
            const auto last_char = printer_model.find_last_not_of(" \t\r\n");
            if (last_char != std::string::npos && printer_model[last_char] == '2')
                return ElegooPrinterType::CC2;
 
            return ElegooPrinterType::CC;
        }

References CC, CC2, classify_printer_model(), and Other.

Referenced by classify_printer_model(), and lookup_cc2_serial_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

escape_path_by_element()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::escape_path_by_element

(

const boost::filesystem::path &

path

)

        {
            std::string ret_val = escape_string(path.filename().string());
            boost::filesystem::path parent(path.parent_path());
            while (!parent.empty() && parent.string() != "/") // "/" check is for case "/file.gcode" was inserted. Then boost takes "/" as parent_path.
            {
                ret_val = escape_string(parent.filename().string()) + "/" + ret_val;
                parent = parent.parent_path();
            }
            return ret_val;
        }

References escape_path_by_element(), and escape_string().

Referenced by escape_path_by_element().

Here is the call graph for this function:

Here is the caller graph for this function:

escape_string()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::escape_string

(

const std::string &

unescaped

)

        {
            std::string ret_val;
            CURL* curl = curl_easy_init();
            if (curl) {
                char* decoded = curl_easy_escape(curl, unescaped.c_str(), unescaped.size());
                if (decoded) {
                    ret_val = std::string(decoded);
                    curl_free(decoded);
                }
                curl_easy_cleanup(curl);
            }
            return ret_val;
        }

References escape_string().

Referenced by escape_path_by_element(), and escape_string().

Here is the call graph for this function:

Here is the caller graph for this function:

filename_to_utf8()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::filename_to_utf8

(

const boost::filesystem::path &

path

)

            {
        #ifdef WIN32
                return boost::nowide::narrow(path.filename().wstring());
        #else
                return path.filename().string();
        #endif
            }

References filename_to_utf8().

Referenced by filename_to_utf8().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cc2_token()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::get_cc2_token

(

const std::string &

apikey

)

        {
            return apikey.empty() ? ELEGOO_CC2_DEFAULT_TOKEN : apikey;
        }

References ELEGOO_CC2_DEFAULT_TOKEN, and get_cc2_token().

Referenced by get_cc2_token(), and lookup_cc2_serial_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

load_sn_from_config()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::load_sn_from_config

(

const std::string &

host_ip

)

        {
            if (host_ip.empty())
                return {};
            AppConfig* app_cfg = GUI::get_app_config();
            if (app_cfg == nullptr)
                return {};
            return app_cfg->get(ELEGOO_DEV_SN_SECTION, host_ip);
        }

References ELEGOO_DEV_SN_SECTION, Slic3r::AppConfig::get(), Slic3r::GUI::get_app_config(), and load_sn_from_config().

Referenced by load_sn_from_config(), and lookup_cc2_serial_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

lookup_cc2_serial()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::lookup_cc2_serial

(

DynamicPrintConfig *

config

)

        {
            if (config == nullptr)
                return {};
            return lookup_cc2_serial_impl(config->opt_string("printer_model"),
                                          config->opt_string("print_host"),
                                          config->opt_string("printhost_apikey"));
        }

References lookup_cc2_serial(), lookup_cc2_serial_impl(), and Slic3r::DynamicConfig::opt_string().

Referenced by lookup_cc2_serial().

Here is the call graph for this function:

Here is the caller graph for this function:

lookup_cc2_serial_impl()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::lookup_cc2_serial_impl	(	const std::string &	printer_model,
		const std::string &	print_host,
		const std::string &	apikey )

        {
            if (classify_printer_model(printer_model) != ElegooPrinterType::CC2)
                return {};
 
            const std::string host_ip = Http::get_host_header_value(print_host);
            const std::string token   = get_cc2_token(apikey);
            std::string       sn      = lookup_sn(host_ip, token);
            if (sn.empty())
                sn = load_sn_from_config(host_ip);
            return sn;
        }

References CC2, classify_printer_model(), get_cc2_token(), Slic3r::Http::get_host_header_value(), load_sn_from_config(), lookup_cc2_serial_impl(), and lookup_sn().

Referenced by lookup_cc2_serial(), and lookup_cc2_serial_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

lookup_sn()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::lookup_sn	(	const std::string &	host_ip,
		const std::string &	token )

        {
            std::lock_guard<std::mutex> lock(s_sn_cache_mutex);
            auto it = s_sn_cache.find(sn_cache_key(host_ip, token));
            return it != s_sn_cache.end() ? it->second : std::string{};
        }

References lookup_sn(), s_sn_cache, s_sn_cache_mutex, and sn_cache_key().

Referenced by lookup_cc2_serial_impl(), and lookup_sn().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_cc2_response()

bool Slic3r::anonymous_namespace{ElegooLink.cpp}::parse_cc2_response	(	const std::string &	body,
		std::string &	error_message,
		std::string *	serial_number = nullptr )

        {
            try {
                pt::ptree          root;
                std::istringstream is(body);
                pt::read_json(is, root);
 
                const int error_code = root.get<int>("error_code", -1);
                if (error_code != 0) {
                    error_message = root.get<std::string>("message", _u8L("Printer returned an error"));
                    if (error_message.empty())
                        error_message = _u8L("Printer returned an error");
                    error_message += " (" + std::to_string(error_code) + ")";
                    return false;
                }
 
                if (serial_number != nullptr) {
                    const auto system_info = root.get_child_optional("system_info");
                    if (!system_info) {
                        error_message = _u8L("Missing system_info in response");
                        return false;
                    }
 
                    const auto sn = system_info->get_optional<std::string>("sn");
                    if (!sn || sn->empty()) {
                        error_message = _u8L("Missing printer serial number in response");
                        return false;
                    }
                    *serial_number = *sn;
                }
 
                return true;
            } catch (const std::exception&) {
                error_message = _u8L("Error parsing response");
                return false;
            }
        }

References _u8L, and parse_cc2_response().

Referenced by parse_cc2_response().

Here is the call graph for this function:

Here is the caller graph for this function:

path_to_utf8()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::path_to_utf8

(

const boost::filesystem::path &

path

)

            {
        #ifdef WIN32
                return boost::nowide::narrow(path.wstring());
        #else
                return path.string();
        #endif
            }

References path_to_utf8().

Referenced by path_to_utf8().

Here is the call graph for this function:

Here is the caller graph for this function:

persist_sn()

void Slic3r::anonymous_namespace{ElegooLink.cpp}::persist_sn	(	const std::string &	host_ip,
		const std::string &	token,
		const std::string &	sn )

        {
            if (host_ip.empty() || sn.empty())
                return;
            cache_sn(host_ip, token, sn);
            AppConfig* app_cfg = GUI::get_app_config();
            if (app_cfg == nullptr)
                return;
            app_cfg->set_str(ELEGOO_DEV_SN_SECTION, host_ip, sn);
        }

References cache_sn(), ELEGOO_DEV_SN_SECTION, Slic3r::GUI::get_app_config(), persist_sn(), and Slic3r::AppConfig::set_str().

Referenced by persist_sn().

Here is the call graph for this function:

Here is the caller graph for this function:

sn_cache_key()

std::string Slic3r::anonymous_namespace{ElegooLink.cpp}::sn_cache_key	(	const std::string &	host_ip,
		const std::string &	token )

        {
            return host_ip + ":" + token;
        }

References sn_cache_key().

Referenced by cache_sn(), lookup_sn(), and sn_cache_key().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ELEGOO_CC2_DEFAULT_TOKEN

const char* Slic3r::anonymous_namespace{ElegooLink.cpp}::ELEGOO_CC2_DEFAULT_TOKEN = "123456"

constexpr

Referenced by get_cc2_token().

ELEGOO_DEV_SN_SECTION

const char* Slic3r::anonymous_namespace{ElegooLink.cpp}::ELEGOO_DEV_SN_SECTION = "dev_sn"

constexpr

Referenced by load_sn_from_config(), and persist_sn().

s_sn_cache

std::map<std::string, std::string> Slic3r::anonymous_namespace{ElegooLink.cpp}::s_sn_cache

static

Referenced by cache_sn(), and lookup_sn().

s_sn_cache_mutex

std::mutex Slic3r::anonymous_namespace{ElegooLink.cpp}::s_sn_cache_mutex

static

Referenced by cache_sn(), and lookup_sn().