#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Config.hpp>

Inheritance diagram for Slic3r::StaticConfig:

Collaboration diagram for Slic3r::StaticConfig:

Public Member Functions
	StaticConfig ()
t_config_option_keys	keys () const
	Gets list of config option names for each config option of this->def, which has a static counter-part defined by the derived object and which could be resolved by this->optptr(key) call.
virtual const ConfigDef *	def () const =0
virtual ConfigOption *	optptr (const t_config_option_key &opt_key, bool create=false)=0
virtual const ConfigOption *	optptr (const t_config_option_key &opt_key) const=0
virtual bool	apply_to (ConfigBase &) const
ConfigOption *	option (const t_config_option_key &opt_key, bool create=false)
template<typename TYPE>
TYPE *	option (const t_config_option_key &opt_key, bool create=false)
const ConfigOption *	option (const t_config_option_key &opt_key) const
ConfigOption *	option_throw (const t_config_option_key &opt_key, bool create=false)
template<typename TYPE>
TYPE *	option_throw (const t_config_option_key &opt_key, bool create=false)
const ConfigOption *	option_throw (const t_config_option_key &opt_key) const
void	apply (const ConfigBase &other, bool ignore_nonexistent=false)
void	apply_only (const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent=false)
bool	equals (const ConfigBase &other, const std::set< std::string > *skipped_keys=nullptr) const
t_config_option_keys	diff (const ConfigBase &other) const
t_config_option_keys	equal (const ConfigBase &other) const
std::string	opt_serialize (const t_config_option_key &opt_key) const
void	set (const std::string &opt_key, bool value, bool create=false)
void	set (const std::string &opt_key, int value, bool create=false)
void	set (const std::string &opt_key, double value, bool create=false)
void	set (const std::string &opt_key, const char *value, bool create=false)
void	set (const std::string &opt_key, const std::string &value, bool create=false)
bool	set_deserialize_nothrow (const t_config_option_key &opt_key_src, const std::string &value_src, ConfigSubstitutionContext &substitutions, bool append=false)
void	set_deserialize (const t_config_option_key &opt_key, const std::string &str, ConfigSubstitutionContext &config_substitutions, bool append=false)
void	set_deserialize (std::initializer_list< SetDeserializeItem > items, ConfigSubstitutionContext &substitutions)
void	set_deserialize_strict (const t_config_option_key &opt_key, const std::string &str, bool append=false)
void	set_deserialize_strict (std::initializer_list< SetDeserializeItem > items)
double	get_abs_value_at (const t_config_option_key &opt_key, size_t index) const
double	get_abs_value (const t_config_option_key &opt_key) const
double	get_abs_value (const t_config_option_key &opt_key, double ratio_over) const
void	setenv_ () const
ConfigSubstitutions	load (const std::string &file, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load (const boost::property_tree::ptree &tree, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load_string_map (std::map< std::string, std::string > &key_values, ForwardCompatibilitySubstitutionRule compatibility_rule)
int	load_from_json (const std::string &file, ConfigSubstitutionContext &substitutions, bool load_inherits_in_config, std::map< std::string, std::string > &key_values, std::string &reason)
ConfigSubstitutions	load_from_json (const std::string &file, ForwardCompatibilitySubstitutionRule compatibility_rule, std::map< std::string, std::string > &key_values, std::string &reason)
ConfigSubstitutions	load_from_ini (const std::string &file, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load_from_ini_string (const std::string &data, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load_from_ini_string_commented (std::string &&data, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load_from_gcode_file (const std::string &file, ForwardCompatibilitySubstitutionRule compatibility_rule)
void	save (const std::string &file) const
void	save_to_json (const std::string &file, const std::string &name, const std::string &from, const std::string &version) const
void	save_to_json (std::ostream &os, const std::string &name, const std::string &from, const std::string &version, bool replace_invalid_utf8=false) const
void	update_plugin_manifest ()
void	null_nullables ()
bool	has (const t_config_option_key &opt_key) const

Static Public Member Functions
static size_t	load_from_gcode_string_legacy (ConfigBase &config, const char *str, ConfigSubstitutionContext &substitutions)
static void	set_resolve_capability_fn (std::function< std::string(std::string, std::string)> fn)

Protected Member Functions
void	set_defaults ()
	Set all statically defined config options to their defaults defined by this->def().
virtual void	handle_legacy (t_config_option_key &, std::string &) const
virtual void	handle_legacy_composite ()

Private Member Functions
bool	set_deserialize_raw (const t_config_option_key &opt_key_src, const std::string &value, ConfigSubstitutionContext &substitutions, bool append)
void	save_plugin_collection (const std::string &opt_key, const ConfigOption *opt, std::vector< std::string > &plugin_refs) const
std::vector< std::string >	collect_plugin_manifest () const

Static Private Attributes
static std::function< std::string(std::string, std::string)>	resolve_capability_fn = nullptr

Detailed Description

Constructor & Destructor Documentation

◆ StaticConfig()

Slic3r::StaticConfig::StaticConfig ( )

inline

3133{}

Member Function Documentation

◆ apply()

void Slic3r::ConfigBase::apply	(	const ConfigBase &	other,
		bool	ignore_nonexistent = false )

inlineinherited

2803 { if (! other.apply_to(*this)) this->apply_only(other, other.keys(), ignore_nonexistent); }

Slic3r::ConfigBase::apply_only

void apply_only(const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent=false)

Definition Config.cpp:484

References ConfigBase(), apply_only(), apply_to(), and keys().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_only()

void Slic3r::ConfigBase::apply_only	(	const ConfigBase &	other,
		const t_config_option_keys &	keys,
		bool	ignore_nonexistent = false )

inherited

{
    // loop through options and apply them
    for (const t_config_option_key &opt_key : keys) {
        // Create a new option with default value for the key.
        // If the key is not in the parameter definition, or this ConfigBase is a static type and it does not support the parameter,
        // an exception is thrown if not ignore_nonexistent.
        ConfigOption *my_opt = this->option(opt_key, true);
        if (my_opt == nullptr) {
            // opt_key does not exist in this ConfigBase and it cannot be created, because it is not defined by this->def().
            // This is only possible if other is of DynamicConfig type.
            if (auto n = opt_key.find('#'); n != std::string::npos) {
                auto opt_key2 = opt_key.substr(0, n);
                auto my_opt2 = dynamic_cast<ConfigOptionVectorBase*>(this->option(opt_key2));
                auto other_opt = other.option(opt_key2);
                if (my_opt2 == nullptr && other_opt) {
                    my_opt2 = dynamic_cast<ConfigOptionVectorBase *>(this->option(opt_key2, true));
                    if (my_opt2->empty()) {
                        my_opt2->resize(1, other_opt);
                    }
                }   
                if (my_opt2) {
                    int index = std::atoi(opt_key.c_str() + n + 1);
                    if (other_opt)
                        my_opt2->set_at(other_opt, index, index);
                    continue;
                }
            }
            if (ignore_nonexistent)
                continue;
            throw UnknownOptionException(opt_key);
        }
    const ConfigOption *other_opt = other.option(opt_key);
    if (other_opt == nullptr) {
            // The key was not found in the source config, therefore it will not be initialized!
//      printf("Not found, therefore not initialized: %s\n", opt_key.c_str());
    } else
            my_opt->set(other_opt);
    }
}

References ConfigBase(), keys(), option(), and Slic3r::ConfigOption::set().

Referenced by apply(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::Preset::load_external_config(), Slic3r::PresetCollection::load_external_preset(), Slic3r::PresetCollection::load_preset(), Slic3r::PresetCollection::load_user_preset(), Slic3r::GUI::Tab::may_discard_current_dirty_preset(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::CLI::run(), Slic3r::PresetBundle::save_changes_for_preset(), Slic3r::GUI::CreatePrinterPresetDialog::save_printable_area_config(), and Slic3r::GUI::TabPrintModel::update_model_config().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_to()

virtual bool Slic3r::ConfigBase::apply_to ( ConfigBase & ) const

inlinevirtualinherited

2750{ return false; }

References ConfigBase().

Referenced by apply().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_plugin_manifest()

std::vector< std::string > Slic3r::ConfigBase::collect_plugin_manifest ( ) const

privateinherited

{
    std::vector<std::string> refs;
    if (!resolve_capability_fn)
        return refs;
 
    // Each plugin-backed option (ConfigOptionDef::is_plugin_backed) contributes its resolved
    // reference(s) via save_plugin_collection, which appends in order and skips duplicates, so no
    // second de-duplication pass is needed here.
    for (const std::string& opt_key : this->keys())
        if (const ConfigOption* opt = this->option(opt_key))
            this->save_plugin_collection(opt_key, opt, refs);
    return refs;
}

References keys(), option(), resolve_capability_fn, and save_plugin_collection().

Referenced by save_to_json(), and update_plugin_manifest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ def()

virtual const ConfigDef * Slic3r::ConfigBase::def ( ) const

pure virtualinherited

Implemented in Slic3r::DynamicConfig, Slic3r::DynamicPrintAndCLIConfig, Slic3r::DynamicPrintConfig, and Slic3r::StaticPrintConfig.

References Slic3r::ConfigOptionResolver::optptr().

Referenced by get_abs_value(), get_abs_value_at(), Slic3r::StaticConfig::keys(), load_from_json(), Slic3r::option_of(), save_plugin_collection(), Slic3r::StaticConfig::set_defaults(), and set_deserialize_raw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ diff()

t_config_option_keys Slic3r::ConfigBase::diff ( const ConfigBase & other ) const

inherited

{
    t_config_option_keys diff;
    for (const t_config_option_key &opt_key : this->keys()) {
        const ConfigOption *this_opt  = this->option(opt_key);
        const ConfigOption *other_opt = other.option(opt_key);
        if (this_opt != nullptr && other_opt != nullptr && *this_opt != *other_opt)
            diff.emplace_back(opt_key);
    }
    return diff;
}

References ConfigBase(), diff(), keys(), and option().

Referenced by diff().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ equal()

t_config_option_keys Slic3r::ConfigBase::equal ( const ConfigBase & other ) const

inherited

{
    t_config_option_keys equal;
    for (const t_config_option_key &opt_key : this->keys()) {
        const ConfigOption *this_opt  = this->option(opt_key);
        const ConfigOption *other_opt = other.option(opt_key);
        if (this_opt != nullptr && other_opt != nullptr && *this_opt == *other_opt)
            equal.emplace_back(opt_key);
    }
    return equal;
}

References ConfigBase(), equal(), keys(), and option().

Referenced by equal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ equals()

bool Slic3r::ConfigBase::equals	(	const ConfigBase &	other,
		const std::set< std::string > *	skipped_keys = nullptr ) const

inherited

{
    for (const t_config_option_key &opt_key : this->keys()) {
        if (skipped_keys && (skipped_keys->count(opt_key) != 0))
            continue;
        const ConfigOption *this_opt  = this->option(opt_key);
        const ConfigOption *other_opt = other.option(opt_key);
        if (this_opt != nullptr && other_opt != nullptr && *this_opt != *other_opt)
            return false;
    }
    return true;
}

References ConfigBase(), keys(), and option().

Here is the call graph for this function:

◆ get_abs_value() [1/2]

double Slic3r::ConfigBase::get_abs_value ( const t_config_option_key & opt_key ) const

inherited

{
    // Get stored option value.
    const ConfigOption *raw_opt = this->option(opt_key);
    if (raw_opt == nullptr) {
      std::stringstream ss;
      ss << "You can't define an option that need " << opt_key << " without defining it!";
      throw std::runtime_error(ss.str());
    }
    assert(raw_opt != nullptr);
 
    if (raw_opt->type() == coFloat)
        return static_cast<const ConfigOptionFloat*>(raw_opt)->value;
    if (raw_opt->type() == coInt)
      return static_cast<const ConfigOptionInt *>(raw_opt)->value;
    if (raw_opt->type() == coBool)
      return static_cast<const ConfigOptionBool *>(raw_opt)->value ? 1 : 0;
 
    const ConfigOptionPercent *cast_opt = nullptr;
    if (raw_opt->type() == coFloatOrPercent) {
        auto cofop = static_cast<const ConfigOptionFloatOrPercent*>(raw_opt);
            if (cofop->value == 0 && boost::ends_with(opt_key, "_line_width")) {
                return this->get_abs_value("line_width");
            }
            if (!cofop->percent)
                return cofop->value;
            cast_opt = cofop;
    }
 
    if (raw_opt->type() == coPercent) {
      cast_opt = static_cast<const ConfigOptionPercent *>(raw_opt);
    }
 
    // Get option definition.
    const ConfigDef *def = this->def();
    if (def == nullptr)
        throw NoDefinitionException(opt_key);
    const ConfigOptionDef *opt_def = def->get(opt_key);
 
 
    assert(opt_def != nullptr);
    if (opt_def->ratio_over == "")
        return cast_opt->get_abs_value(1);
    // Compute absolute value over the absolute value of the base option.
    //FIXME there are some ratio_over chains, which end with empty ratio_with.
    // For example, XXX_extrusion_width parameters are not handled by get_abs_value correctly.
    return opt_def->ratio_over.empty() ? 0. :
        static_cast<const ConfigOptionFloatOrPercent*>(raw_opt)->get_abs_value(this->get_abs_value(opt_def->ratio_over));
    
 
    throw ConfigurationError("ConfigBase::get_abs_value(): Not a valid option type for get_abs_value()");
}

References Slic3r::coBool, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coPercent, def(), get_abs_value(), Slic3r::ConfigOptionPercent::get_abs_value(), option(), Slic3r::ConfigOptionDef::ratio_over, Slic3r::ConfigOption::type(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), get_abs_value(), get_abs_value(), Slic3r::GUI::GLGizmoBrimEars::get_brim_default_radius(), Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config(), and Slic3r::GUI::ConfigManipulation::update_print_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_abs_value() [2/2]

double Slic3r::ConfigBase::get_abs_value	(	const t_config_option_key &	opt_key,
		double	ratio_over ) const

inherited

{
    // Get stored option value.
    const ConfigOption *raw_opt = this->option(opt_key);
    // Mirror the single-arg overload — assert() is a no-op under NDEBUG.
    if (raw_opt == nullptr)
        throw ConfigurationError("ConfigBase::get_abs_value(): \"" + opt_key + "\" is not defined");
    if (raw_opt->type() != coFloatOrPercent)
        throw ConfigurationError("ConfigBase::get_abs_value(): opt_key is not of coFloatOrPercent");
    // Compute absolute value.
    return static_cast<const ConfigOptionFloatOrPercent*>(raw_opt)->get_abs_value(ratio_over);
}

References Slic3r::coFloatOrPercent, get_abs_value(), option(), and Slic3r::ConfigOption::type().

Here is the call graph for this function:

◆ get_abs_value_at()

double Slic3r::ConfigBase::get_abs_value_at	(	const t_config_option_key &	opt_key,
		size_t	index ) const

inherited

{
    const ConfigOption *raw_opt = this->option(opt_key);
    assert(raw_opt != nullptr);
    if (raw_opt->type() == coFloats) {
        return static_cast<const ConfigOptionFloats*>(raw_opt)->get_at(index);
    }
    if (raw_opt->type() == coFloatsOrPercents) {
        const ConfigDef *def = this->def();
        if (def == nullptr) throw NoDefinitionException(opt_key);
        const ConfigOptionDef *opt_def = def->get(opt_key);
        assert(opt_def != nullptr);
 
        if (opt_def->ratio_over.empty()) {
            return 0;
        } else {
            const ConfigOption *ratio_opt = this->option(opt_def->ratio_over);
            assert(ratio_opt->type() == coFloats);
            const ConfigOptionFloats *ratio_values = static_cast<const ConfigOptionFloats *>(ratio_opt);
            return static_cast<const ConfigOptionFloatsOrPercents *>(raw_opt)->get_at(index).get_abs_value(ratio_values->get_at(index));
        }
    }
 
    throw ConfigurationError("ConfigBase::get_abs_value_at(): Not a valid option type for get_abs_value_at()");
}

References Slic3r::coFloats, Slic3r::coFloatsOrPercents, def(), Slic3r::ConfigOptionVector< double >::get_at(), option(), Slic3r::ConfigOptionDef::ratio_over, and Slic3r::ConfigOption::type().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_legacy()

virtual void Slic3r::ConfigBase::handle_legacy	(	t_config_option_key &	,
		std::string &	) const

inlineprotectedvirtualinherited

Reimplemented in Slic3r::DynamicPrintAndCLIConfig, Slic3r::DynamicPrintConfig, and Slic3r::StaticPrintConfig.

2757{}

Referenced by load_from_json(), and set_deserialize_nothrow().

Here is the caller graph for this function:

◆ handle_legacy_composite()

virtual void Slic3r::ConfigBase::handle_legacy_composite ( )

inlineprotectedvirtualinherited

Reimplemented in Slic3r::DynamicPrintConfig.

2761{}

Referenced by load(), load_from_gcode_file(), load_from_gcode_string_legacy(), and load_from_json().

Here is the caller graph for this function:

◆ has()

bool Slic3r::ConfigOptionResolver::has ( const t_config_option_key & opt_key ) const

inlineinherited

2697{ return this->optptr(opt_key) != nullptr; }

Slic3r::ConfigOptionResolver::optptr

virtual const ConfigOption * optptr(const t_config_option_key &opt_key) const =0

References optptr().

Here is the call graph for this function:

◆ keys()

t_config_option_keys Slic3r::StaticConfig::keys ( ) const

virtual

Gets list of config option names for each config option of this->def, which has a static counter-part defined by the derived object and which could be resolved by this->optptr(key) call.

Implements Slic3r::ConfigBase.

{
    t_config_option_keys keys;
    assert(this->def() != nullptr);
    for (const auto &opt_def : this->def()->options)
        if (this->option(opt_def.first) != nullptr)
            keys.push_back(opt_def.first);
    return keys;
}

References Slic3r::ConfigBase::def(), keys(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::PresetCollection::add_default_preset(), keys(), and set_defaults().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load() [1/2]

ConfigSubstitutions Slic3r::ConfigBase::load	(	const boost::property_tree::ptree &	tree,
		ForwardCompatibilitySubstitutionRule	compatibility_rule )

inherited

{
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
    for (const boost::property_tree::ptree::value_type &v : tree) {
        try {
            t_config_option_key opt_key = v.first;
            this->set_deserialize(opt_key, v.second.get_value<std::string>(), substitutions_ctxt);
        } catch (UnknownOptionException & /* e */) {
            // ignore
        }
    }
    // Do legacy conversion on a completely loaded dictionary.
    // Perform composite conversions, for example merging multiple keys into one key.
    this->handle_legacy_composite();
    return std::move(substitutions_ctxt.substitutions);
}

References handle_legacy_composite(), set_deserialize(), and Slic3r::ConfigSubstitutionContext::substitutions.

Here is the call graph for this function:

◆ load() [2/2]

ConfigSubstitutions Slic3r::ConfigBase::load	(	const std::string &	file,
		ForwardCompatibilitySubstitutionRule	compatibility_rule )

inherited

{
    std::map<std::string, std::string> key_values;
    if (is_gcode_file(file))
        return this->load_from_gcode_file(file, compatibility_rule);
    else if (is_json_file(file)) {
        std::string reason;
        return this->load_from_json(file, compatibility_rule, key_values, reason);
    }
    else {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "unsupported format for config file" << file;
        return ConfigSubstitutions();
        //return this->load_from_ini(file, compatibility_rule);
    }
}

References Slic3r::is_gcode_file(), Slic3r::is_json_file(), load_from_gcode_file(), and load_from_json().

Referenced by Slic3r::extract_profile(), Slic3r::import_sla_archive(), Slic3r::import_sla_archive(), load_from_ini(), and load_from_ini_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_from_gcode_file()

ConfigSubstitutions Slic3r::ConfigBase::load_from_gcode_file	(	const std::string &	file,
		ForwardCompatibilitySubstitutionRule	compatibility_rule )

inherited

{
    // Read a 64k block from the end of the G-code.
  boost::nowide::ifstream ifs(file);
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  before parse_file %1%") % file.c_str();
    // Look for Slic3r or OrcaSlicer header.
    // Look for the header across the whole file as the G-code may have been extended at the start by a post-processing script or the user.
    //BBS
    bool has_delimiters = true;
    {
        //BBS
        std::string bambuslicer_gcode_header = "; OrcaSlicer";
 
        std::string orcaslicer_gcode_header = std::string("; generated by ");
        orcaslicer_gcode_header += SLIC3R_APP_NAME;
 
        std::string header;
        bool        header_found = false;
        while (std::getline(ifs, header)) {
            // BBS
            const char* line_c = skip_whitespaces(header.c_str());
            if (std::toupper(*line_c) == 'N')
                line_c = skip_word(line_c);
            line_c = skip_whitespaces(line_c);
            // BBS
            if (strncmp(bambuslicer_gcode_header.c_str(), line_c, strlen(bambuslicer_gcode_header.c_str())) == 0 ||
                strncmp(orcaslicer_gcode_header.c_str(), line_c, strlen(orcaslicer_gcode_header.c_str())) == 0) {
                header_found = true;
                break;
            }
        }
        if (!header_found) {
            // TRN %1% is the application name.
            std::string error_message = format(_u8L("Not a G-code file generated by %1%."), SLIC3R_APP_FULL_NAME);
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << error_message;
            throw Slic3r::RuntimeError(error_message.c_str());
        }
    }
 
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
    size_t                    key_value_pairs = 0;
 
    if (has_delimiters)
    {
        //BBS
        // PrusaSlicer starting with 2.4.0-alpha0 delimits the config section stored into G-code with
        // ; CONFIG_BLOCK_START
        // ...
        // ; CONFIG_BLOCK_END
        bool begin_found = false;
        bool end_found   = false;
        std::string line;
        while (std::getline(ifs, line))
            if (line.rfind("; CONFIG_BLOCK_START",0)==0) {
                begin_found = true;
                break;
            }
        if (!begin_found) {
            //BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Configuration block closing tag \"; CONFIG_BLOCK_START\" not found when reading %1%", file);
            // TRN %1% is a tag in the G-code file that must not be translated.
            throw Slic3r::RuntimeError(format(_u8L("Config tag \"%1%\" not found"), "; CONFIG_BLOCK_START"));
        }
        std::string key, value;
        while (std::getline(ifs, line)) {
            if (line.rfind("; CONFIG_BLOCK_END",0)==0) {
                end_found = true;
                break;
            }
            // line should be a valid key = value pair.
            auto pos = line.find('=');
            if (pos != std::string::npos && pos > 1 && line.front() == ';') {
                key   = line.substr(1, pos - 1);
                value = line.substr(pos + 1);
                boost::trim(key);
                boost::trim(value);
                try {
                    this->set_deserialize(key, value, substitutions_ctxt);
                    ++ key_value_pairs;
                } catch (UnknownOptionException & /* e */) {
                    // ignore
                }
            }
        }
        if (!end_found) {
            //BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Configuration block opening tag \"; CONFIG_BLOCK_END\" not found when reading %1%", file);
            throw Slic3r::RuntimeError(format(_u8L("Config tag \"%1%\" not found"), "; CONFIG_BLOCK_END"));
        }
    }
    else
    {
        auto                      header_end_pos = ifs.tellg();
        // Slicer older than 2.4.0-alpha0 do not emit any delimiter.
        // Try a heuristics reading the G-code from back.
        ifs.seekg(0, ifs.end);
        auto file_length = ifs.tellg();
      auto data_length = std::min<std::fstream::pos_type>(65535, file_length - header_end_pos);
      ifs.seekg(file_length - data_length, ifs.beg);
        std::vector<char> data(size_t(data_length) + 1, 0);
        ifs.read(data.data(), data_length);
        ifs.close();
        key_value_pairs = load_from_gcode_string_legacy(*this, data.data(), substitutions_ctxt);
    }
 
    if (key_value_pairs < 80) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Suspiciously low number of configuration values extracted from %1%: %2%", file, key_value_pairs);
        throw Slic3r::RuntimeError(format(_u8L("Suspiciously low number of configuration values extracted from %1%: %2%"), file, key_value_pairs));
    }
 
    // Do legacy conversion on a completely loaded dictionary.
    // Perform composite conversions, for example merging multiple keys into one key.
    this->handle_legacy_composite();
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  finished to parse_file %1%") % file.c_str();
    return std::move(substitutions_ctxt.substitutions);
}

References _u8L, Slic3r::format(), handle_legacy_composite(), load_from_gcode_string_legacy(), set_deserialize(), Slic3r::skip_whitespaces(), Slic3r::skip_word(), SLIC3R_APP_FULL_NAME, and Slic3r::ConfigSubstitutionContext::substitutions.

Referenced by Slic3r::PresetBundle::config_from_gcode(), load(), and Slic3r::GCodeProcessor::process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_from_gcode_string_legacy()

size_t Slic3r::ConfigBase::load_from_gcode_string_legacy	(	ConfigBase &	config,
		const char *	str,
		ConfigSubstitutionContext &	substitutions )

staticinherited

{
    if (str == nullptr)
        return 0;
 
    // BBS. Remove line numbers.
    std::regex match_pattern("\nN[0-9]* *");
    std::string replace_pattern = "\n";
    char* result = (char*)calloc(strlen(str) + 1, 1);
    std::regex_replace(result, str, str + strlen(str), match_pattern, replace_pattern);
 
    // Walk line by line in reverse until a non-configuration key appears.
    const char *data_start = result;
    data_start = skip_whitespaces(data_start);
    if (std::toupper(*data_start) == 'N')
        data_start = skip_word(data_start);
 
    // boost::nowide::ifstream seems to cook the text data somehow, so less then the 64k of characters may be retrieved.
    const char *end = data_start + strlen(data_start);
    size_t num_key_value_pairs = 0;
    for (;;) {
        // Extract next line.
        for (--end; end > data_start && (*end == '\r' || *end == '\n'); --end);
        if (end == data_start)
            break;
        const char *start = end ++;
        for (; start > data_start && *start != '\r' && *start != '\n'; --start);
        if (start == data_start)
            break;
        // Extracted a line from start to end. Extract the key = value pair.
        if (end - (++ start) < 10 || start[0] != ';' || start[1] != ' ')
            break;
        const char *key = start + 2;
        if (!((*key >= 'a' && *key <= 'z') || (*key >= 'A' && *key <= 'Z')))
            // A key must start with a letter.
            break;
        const char *sep = key;
        for (; sep != end && *sep != '='; ++ sep) ;
        if (sep == end || sep[-1] != ' ' || sep[1] != ' ')
            break;
        const char *value = sep + 2;
        if (value > end)
            break;
        const char *key_end = sep - 1;
        if (key_end - key < 3)
            break;
        // The key may contain letters, digits and underscores.
        for (const char *c = key; c != key_end; ++ c)
            if (!((*c >= 'a' && *c <= 'z') || (*c >= 'A' && *c <= 'Z') || (*c >= '0' && *c <= '9') || *c == '_')) {
                key = nullptr;
                break;
            }
        if (key == nullptr)
            break;
        try {
            config.set_deserialize(std::string(key, key_end), std::string(value, end), substitutions);
            ++num_key_value_pairs;
        }
        catch (UnknownOptionException & /* e */) {
            // ignore
        }
        end = start;
    }
 
    // Do legacy conversion on a completely loaded dictionary.
    // Perform composite conversions, for example merging multiple keys into one key.
    config.handle_legacy_composite();
 
    free(result);
    return num_key_value_pairs;
}

References ConfigBase(), handle_legacy_composite(), set_deserialize(), Slic3r::skip_whitespaces(), and Slic3r::skip_word().

Referenced by Slic3r::_3MF_Importer::_extract_print_config_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_print_config_from_archive(), load_from_gcode_file(), and Slic3r::load_from_superslicer_gcode_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_from_ini()

ConfigSubstitutions Slic3r::ConfigBase::load_from_ini	(	const std::string &	file,
		ForwardCompatibilitySubstitutionRule	compatibility_rule )

inherited

{
    try {
        boost::property_tree::ptree tree;
        boost::nowide::ifstream ifs(file);
        boost::property_tree::read_ini(ifs, tree);
        return this->load(tree, compatibility_rule);
    } catch (const ConfigurationError &e) {
        throw ConfigurationError(format(_u8L("Failed loading configuration file \"%1%\": %2%"), file, e.what()));
    }
}

References _u8L, Slic3r::format(), and load().

Referenced by Slic3r::_BBS_3MF_Importer::_extract_project_embedded_presets_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_from_ini_string()

ConfigSubstitutions Slic3r::ConfigBase::load_from_ini_string	(	const std::string &	data,
		ForwardCompatibilitySubstitutionRule	compatibility_rule )

inherited

{
    boost::property_tree::ptree tree;
    std::istringstream iss(data);
    boost::property_tree::read_ini(iss, tree);
    return this->load(tree, compatibility_rule);
}

References load().

Referenced by Slic3r::GUI::Plater::priv::load_files(), and load_from_ini_string_commented().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_from_ini_string_commented()

ConfigSubstitutions Slic3r::ConfigBase::load_from_ini_string_commented	(	std::string &&	data,
		ForwardCompatibilitySubstitutionRule	compatibility_rule )

inherited

{
    // Convert the "data" string into INI format by removing the semi-colons at the start of a line.
    // Also the "; generated by PrusaSlicer ..." comment line will be removed.
    size_t j = 0;
    for (size_t i = 0; i < data.size();)
        if (i == 0 || data[i] == '\n') {
            // Start of a line.
            if (data[i] == '\n') {
                // Consume LF, don't keep empty lines.
                if (j > 0 && data[j - 1] != '\n')
                    data[j ++] = data[i];
                ++ i;
            }
            // Skip all leading spaces;
            for (; i < data.size() && (data[i] == ' ' || data[i] == '\t'); ++ i) ;
            // Skip the semicolon (comment indicator).
            if (i < data.size() && data[i] == ';')
                ++ i;
            // Skip all leading spaces after semicolon.
            for (; i < data.size() && (data[i] == ' ' || data[i] == '\t'); ++ i) ;
            if (strncmp(data.data() + i, "generated by ", 13) == 0) {
                // Skip the "; generated by ..." line.
                for (; i < data.size() && data[i] != '\n'; ++ i);
            }
        } else if (data[i] == '\r' && i + 1 < data.size() && data[i + 1] == '\n') {
            // Skip CR.
            ++ i;
        } else {
            // Consume the rest of the data.
            data[j ++] = data[i ++];
        }
    data.erase(data.begin() + j, data.end());
 
    return this->load_from_ini_string(data, compatibility_rule);
}

References load_from_ini_string().

Here is the call graph for this function:

◆ load_from_json() [1/2]

int Slic3r::ConfigBase::load_from_json	(	const std::string &	file,
		ConfigSubstitutionContext &	substitutions,
		bool	load_inherits_in_config,
		std::map< std::string, std::string > &	key_values,
		std::string &	reason )

inherited

{
    json j;
    std::list<std::string> different_settings_append;
    std::string new_support_style;
    std::string is_infill_first;
    std::string get_wall_sequence;
    bool is_project_settings = false;
 
    CNumericLocalesSetter locales_setter;
 
    std::function<bool(const json::const_iterator&, const char,const char,const bool,std::string&)> parse_str_arr = [&parse_str_arr](const json::const_iterator& it, const char single_sep,const char array_sep,const bool escape_string_style,std::string& value_str)->bool {
        // must have consistent type name
        std::string consistent_type;
        for (auto iter = it.value().begin(); iter != it.value().end(); ++iter) {
            if (consistent_type.empty())
                consistent_type = iter.value().type_name();
            else {
                if (consistent_type != iter.value().type_name())
                    return false;
            }
        }
 
        bool first = true;
        for (auto iter = it.value().begin(); iter != it.value().end(); iter++) {
            if (iter.value().is_array()) {
                if (!first)
                    value_str += array_sep;
                else
                    first = false;
                bool success = parse_str_arr(iter, single_sep, array_sep,escape_string_style, value_str);
                if (!success)
                    return false;
            }
            else if (iter.value().is_string()) {
                if (!first)
                    value_str += single_sep;
                else
                    first = false;
                if (!escape_string_style)
                    value_str += iter.value();
                else {
                    value_str += "\"";
                    value_str += escape_string_cstyle(iter.value());
                    value_str += "\"";
                }
            }
            else {
                //should not happen
                return false;
            }
        }
        return true;
        };
 
    try {
        boost::nowide::ifstream ifs(file);
        ifs >> j;
        ifs.close();
 
        const ConfigDef* config_def = this->def();
        if (config_def == nullptr) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": no config defs!";
            return -1;
        }
        //parse the json elements
        for (auto it = j.begin(); it != j.end(); it++) {
            if (ascii_iequals(it.key(), BBL_JSON_KEY_VERSION)) {
                key_values.emplace(BBL_JSON_KEY_VERSION, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_IS_CUSTOM)) {
                //skip it
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_NAME)) {
                key_values.emplace(BBL_JSON_KEY_NAME, it.value());
                if (it.value() == "project_settings")
                    is_project_settings = true;
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_URL)) {
                key_values.emplace(BBL_JSON_KEY_URL, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_TYPE)) {
                key_values.emplace(BBL_JSON_KEY_TYPE, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_SETTING_ID)) {
                key_values.emplace(BBL_JSON_KEY_SETTING_ID, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_FILAMENT_ID)) {
                key_values.emplace(BBL_JSON_KEY_FILAMENT_ID, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_FROM)) {
                key_values.emplace(BBL_JSON_KEY_FROM, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_DESCRIPTION)) {
                key_values.emplace(BBL_JSON_KEY_DESCRIPTION, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_INSTANTIATION)) {
                key_values.emplace(BBL_JSON_KEY_INSTANTIATION, it.value());
            }
            else if (!load_inherits_to_config && ascii_iequals(it.key(), BBL_JSON_KEY_INHERITS)) {
                key_values.emplace(BBL_JSON_KEY_INHERITS, it.value());
            }
            else if (!load_inherits_to_config && ascii_iequals(it.key(), BBL_JSON_KEY_INCLUDES)) {
                key_values.emplace(BBL_JSON_KEY_INCLUDES, it.value().dump());
            } else if (ascii_iequals(it.key(), ORCA_JSON_KEY_RENAMED_FROM)) {
                key_values.emplace(ORCA_JSON_KEY_RENAMED_FROM, it.value());
            } else {
                t_config_option_key opt_key = it.key();
                std::string value_str;
 
                if (it.value().is_string()) {
                    //bool test1 = (it.key() == std::string("end_gcode"));
                    this->set_deserialize(opt_key, it.value(), substitution_context);
                    //some logic for special values
                    if (opt_key == "support_type") {
                        //std::string new_value = dynamic_cast<ConfigOptionString*>(this->option(opt_key))->value;
                        if (it.value() == "hybrid(auto)") {
                            different_settings_append.push_back(opt_key);
                            different_settings_append.push_back("support_style");
                            new_support_style = "tree_hybrid";
                        }
                    } else if (opt_key == "wall_infill_order") {
                        //BBS: check wall_infill order to decide if it be different and append to diff_setting_append
                        if (it.value() == "outer wall/inner wall/infill" || it.value() == "infill/outer wall/inner wall" || it.value() == "inner-outer-inner wall/infill") {
                            get_wall_sequence = "wall_seq_diff_to_system";
                        }
 
                        if (it.value() == "infill/outer wall/inner wall" || it.value() == "infill/inner wall/outer wall") {
                            different_settings_append.push_back("is_infill_first");
                            is_infill_first = "true";
                        }
                    }
                }
                else if (it.value().is_array()) {
                    t_config_option_key opt_key_src = opt_key;
                    this->handle_legacy(opt_key, value_str);
                    if (opt_key.empty()) {
                        //BBS: record these options
                        substitution_context.unrecogized_keys.push_back(opt_key_src);
                        continue;
                    }
                    bool valid = true, first = true;
                    const ConfigOptionDef* optdef = config_def->get(opt_key);
                    if (optdef == nullptr) {
                        // If we didn't find an option, look for any other option having this as an alias.
                        for (const auto& opt : config_def->options) {
                            for (const t_config_option_key& opt_key2 : opt.second.aliases) {
                                if (opt_key2 == opt_key) {
                                    opt_key = opt.first;
                                    optdef = &opt.second;
                                    break;
                                }
                            }
                            if (optdef != nullptr)
                                break;
                        }
                    }
 
                    char single_sep = ',';
                    char array_sep = '#';  // currenty not used
                    bool escape_string_type = false;
                    if (optdef) {
                        switch (optdef->type)
                        {
                        case coStrings:
                            escape_string_type = true;
                            single_sep = ';';
                            break;
                        case coPointsGroups:
                            single_sep = '#';
                            break;
                        default:
                            break;
                        }
                    }
 
                    // BBS: we only support 2 depth array
                    valid = parse_str_arr(it, single_sep, array_sep,escape_string_type, value_str);
                    if (!valid) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": parse " << file << " error, invalid json array for " << it.key();
                        break;
                    }
                    if (valid)
                        this->set_deserialize(opt_key, value_str, substitution_context);
                }
                else {
                    //should not happen
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" error, invalid json type for " << it.key();
                }
            }
        }
        if (!different_settings_append.empty()) {
            if (!new_support_style.empty()) {
                ConfigOptionEnum<SupportMaterialStyle>* opt = this->option<ConfigOptionEnum<SupportMaterialStyle>>("support_style", true);
                opt->value = smsTreeHybrid;
            }
 
            if (!is_infill_first.empty()) {
                ConfigOptionBool *opt = this->option<ConfigOptionBool>("is_infill_first", true);
                opt->value = true;
            }
 
            if (is_project_settings) {
                std::vector<std::string>& different_settings = this->option<ConfigOptionStrings>("different_settings_to_system", true)->values;
                size_t size = different_settings.size();
                if (size == 0) {
                    const auto *filament_ids = this->option<ConfigOptionStrings>("filament_settings_id");
                    size = (filament_ids ? filament_ids->values.size() : 0) + 2;
                    different_settings.resize(size);
                }
 
                std::vector<bool> is_first(size, false);
                std::vector<std::vector<std::string>> original_diffs(size);
                for (int index = 0; index < size; index++)
                {
                    if (different_settings[index].empty()) {
                        is_first[index] = true;
                    }
                    else {
                        // remove unneeded key
                        if (get_wall_sequence.empty()) {
                            std::string wall_sqe_string = "wall_sequence";
                            int pos=different_settings[index].find(wall_sqe_string);
 
                            if (pos != different_settings[index].npos) {
                                int erase_len = wall_sqe_string.size();
                                if (pos + erase_len < different_settings[index].size() && different_settings[index][pos + erase_len] == ';')
                                    erase_len++;
                                different_settings[index].erase(pos, erase_len);
                            }
 
                        }
 
                        if (different_settings[index].empty()) {
                            is_first[index] = true;
                            continue;
                        }
 
                        Slic3r::unescape_strings_cstyle(different_settings[index], original_diffs[index]);
                    }
                }
 
                for (auto diff_key : different_settings_append)
                {
                    //get the index in the group
                    int index = 0;
                    bool need_insert = true;
                    if (diff_key == "support_type")
                        index = 0;
                    else if (diff_key == "support_style")
                        index = 0;
                    else if (diff_key == "is_infill_first")
                        index = 0;
 
                    //check whether exist firstly
                    if (!original_diffs[index].empty()) {
                        for (int j = 0; j < original_diffs[index].size(); j++) {
                            if (original_diffs[index][j] == diff_key) {
                                need_insert = false;
                                break;
                            }
                        }
                    }
                    if (!need_insert)
                        continue;
 
                    //insert this key
                    if (!is_first[index])
                        different_settings[index] += ";";
                    else
                        is_first[index] = false;
                    different_settings[index] += diff_key;
                }
            }
        }
        
        // Do legacy conversion on a completely loaded dictionary.
        // Perform composite conversions, for example merging multiple keys into one key.
        this->handle_legacy_composite();
        return 0;
    }
    catch (const std::ifstream::failure &err)  {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a ifstream error, reason = " << err.what();
        reason = std::string("ifstreamError: ") + err.what();
        //throw ConfigurationError(format("Failed loading configuration file \"%1%\": %2%", file, e.what()));
    }
    catch(nlohmann::detail::parse_error &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a nlohmann::detail::parse_error, reason = " << err.what();
        reason = std::string("JsonParseError: ") + err.what();
        //throw ConfigurationError(format("Failed loading configuration file \"%1%\": %2%", file, err.what()));
    }
    catch(std::exception &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a generic exception, reason = " << err.what();
        reason = std::string("std::exception: ") + err.what();
    }
    return -1;
}

References Slic3r::ascii_iequals(), BBL_JSON_KEY_DESCRIPTION, BBL_JSON_KEY_FILAMENT_ID, BBL_JSON_KEY_FROM, BBL_JSON_KEY_INCLUDES, BBL_JSON_KEY_INHERITS, BBL_JSON_KEY_INSTANTIATION, BBL_JSON_KEY_IS_CUSTOM, BBL_JSON_KEY_NAME, BBL_JSON_KEY_SETTING_ID, BBL_JSON_KEY_TYPE, BBL_JSON_KEY_URL, BBL_JSON_KEY_VERSION, Slic3r::coPointsGroups, Slic3r::coStrings, def(), Slic3r::empty(), Slic3r::escape_string_cstyle(), Slic3r::filament_ids(), Slic3r::ConfigDef::get(), handle_legacy(), handle_legacy_composite(), Slic3r::is_infill_first(), option(), Slic3r::ConfigDef::options, ORCA_JSON_KEY_RENAMED_FROM, set_deserialize(), Slic3r::smsTreeHybrid, Slic3r::ConfigOptionDef::type, Slic3r::unescape_strings_cstyle(), Slic3r::ConfigSubstitutionContext::unrecogized_keys, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::_BBS_3MF_Importer::_extract_project_config_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_project_embedded_presets_from_archive(), Slic3r::PresetBundle::import_json_presets(), load(), load_from_json(), Slic3r::PhysicalPrinterCollection::load_printers(), and Slic3r::PresetCollection::resolve_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_from_json() [2/2]

ConfigSubstitutions Slic3r::ConfigBase::load_from_json	(	const std::string &	file,
		ForwardCompatibilitySubstitutionRule	compatibility_rule,
		std::map< std::string, std::string > &	key_values,
		std::string &	reason )

inherited

{
    int ret = 0;
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
 
    ret = load_from_json(file, substitutions_ctxt, true, key_values, reason);
    return std::move(substitutions_ctxt.substitutions);
}

References load_from_json(), and Slic3r::ConfigSubstitutionContext::substitutions.

Here is the call graph for this function:

◆ load_string_map()

ConfigSubstitutions Slic3r::ConfigBase::load_string_map	(	std::map< std::string, std::string > &	key_values,
		ForwardCompatibilitySubstitutionRule	compatibility_rule )

inherited

{
    CNumericLocalesSetter locales_setter;
 
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
    std::map<std::string, std::string>::iterator it;
    for (it = key_values.begin(); it != key_values.end(); it++) {
        try {
            t_config_option_key opt_key = it->first;
            this->set_deserialize(opt_key, it->second, substitutions_ctxt);
        }
        catch (UnknownOptionException& /* e */) {
            // ignore
        }
    }
    return std::move(substitutions_ctxt.substitutions);
}

References set_deserialize(), and Slic3r::ConfigSubstitutionContext::substitutions.

Referenced by Slic3r::PresetCollection::load_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ null_nullables()

void Slic3r::ConfigBase::null_nullables ( )

inherited

{
    for (const std::string &opt_key : this->keys()) {
        ConfigOption *opt = this->optptr(opt_key, false);
        assert(opt != nullptr);
        if (opt->nullable())
          opt->deserialize("nil", ForwardCompatibilitySubstitutionRule::Disable);
    }
}

References Slic3r::Disable, keys(), and optptr().

Here is the call graph for this function:

◆ opt_serialize()

std::string Slic3r::ConfigBase::opt_serialize ( const t_config_option_key & opt_key ) const

inherited

{
    const ConfigOption* opt = this->option(opt_key);
    assert(opt != nullptr);
    return opt->serialize();
}

References option().

Referenced by Slic3r::_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::GCode::_do_export(), Slic3r::GCode::append_full_config(), Slic3r::config_value_or_none(), Slic3r::GUI::Plater::export_published_3mf(), and save().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ option() [1/3]

const ConfigOption * Slic3r::ConfigOptionResolver::option ( const t_config_option_key & opt_key ) const

inlineinherited

2699{ return this->optptr(opt_key); }

◆ option() [2/3]

template<typename TYPE>

TYPE * Slic3r::ConfigBase::option	(	const t_config_option_key &	opt_key,
		bool	create = false )

inlineinherited

    {
        ConfigOption* opt = this->optptr(opt_key, create);
        if (opt != nullptr && opt->type() != TYPE::static_type()) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": attempt to access option with wrong type: " << opt_key;
            return nullptr;
        }
        return static_cast<TYPE*>(opt);
    }

References optptr().

Here is the call graph for this function:

◆ option() [3/3]

ConfigOption * Slic3r::ConfigBase::option	(	const t_config_option_key &	opt_key,
		bool	create = false )

inlineinherited

2769 { return this->optptr(opt_key, create); }

References optptr().

Here is the call graph for this function:

◆ option_throw() [1/3]

const ConfigOption * Slic3r::ConfigOptionResolver::option_throw ( const t_config_option_key & opt_key ) const

inlineinherited

    {
        const ConfigOption* opt = this->optptr(opt_key);
        if (opt == nullptr)
            throw UnknownOptionException(opt_key);
        return opt;
    }

◆ option_throw() [2/3]

template<typename TYPE>

TYPE * Slic3r::ConfigBase::option_throw	(	const t_config_option_key &	opt_key,
		bool	create = false )

inlineinherited

    {
        ConfigOption *opt = this->option_throw(opt_key, create);
        if (opt->type() != TYPE::static_type())
            throw BadOptionTypeException("Conversion to a wrong type");
        return static_cast<TYPE*>(opt);
    }

References option_throw().

Here is the call graph for this function:

◆ option_throw() [3/3]

ConfigOption * Slic3r::ConfigBase::option_throw	(	const t_config_option_key &	opt_key,
		bool	create = false )

inlineinherited

    {
        ConfigOption *opt = this->optptr(opt_key, create);
        if (opt == nullptr)
            throw UnknownOptionException(opt_key);
        return opt;
    }

References optptr().

Referenced by option_throw(), set(), set(), set(), set(), and set().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ optptr() [1/2]

virtual const ConfigOption * Slic3r::ConfigOptionResolver::optptr ( const t_config_option_key & opt_key ) const

virtualinherited

Implements Slic3r::ConfigOptionResolver.

Reimplemented in Slic3r::DynamicConfig.

◆ optptr() [2/2]

virtual ConfigOption * Slic3r::ConfigBase::optptr	(	const t_config_option_key &	opt_key,
		bool	create = false )

pure virtualinherited

Implemented in Slic3r::DynamicConfig.

Referenced by null_nullables(), option(), and option_throw().

Here is the caller graph for this function:

◆ save()

void Slic3r::ConfigBase::save ( const std::string & file ) const

inherited

{
    boost::nowide::ofstream c;
    c.open(file, std::ios::out | std::ios::trunc);
    c << "# " << Slic3r::header_slic3r_generated() << std::endl;
    for (const std::string &opt_key : this->keys())
        c << opt_key << " = " << this->opt_serialize(opt_key) << std::endl;
    c.close();
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
}

References Slic3r::header_slic3r_generated(), keys(), and opt_serialize().

Here is the call graph for this function:

◆ save_plugin_collection()

void Slic3r::ConfigBase::save_plugin_collection	(	const std::string &	opt_key,
		const ConfigOption *	opt,
		std::vector< std::string > &	plugin_refs ) const

privateinherited

                                                                                                                                  {
    // Full plugin capability references ("name;uuid;capability") can only be derived through the
    // resolver registered by the GUI once plugins are loaded. In non-GUI/headless contexts (e.g.
    // the CLI) it stays null, so skip silently rather than calling an empty std::function.
    if (!resolve_capability_fn)
        return;
 
    // A plugin-backed option declares its capability type via ConfigOptionDef::plugin_type (the same
    // metadata PluginResolver::find_option_for_capability scans). Deriving off the def rather than a
    // per-key branch keeps this generic across every plugin-backed option.
    const ConfigDef*       def     = this->def();
    const ConfigOptionDef* opt_def = def ? def->get(opt_key) : nullptr;
    if (opt_def == nullptr || !opt_def->is_plugin_backed())
        return;
    const std::string& type = opt_def->plugin_type;
 
    // Resolve a single bare capability value into its full reference and append it, skipping unset
    // values, capabilities that could not be resolved (resolver returns ""), and duplicates already
    // collected (preserving insertion order).
    const auto append_ref = [&plugin_refs, &type](const std::string& capability_value) {
        if (capability_value.empty())
            return;
        std::string ref = resolve_capability_fn(capability_value, type);
        if (!ref.empty() && std::find(plugin_refs.begin(), plugin_refs.end(), ref) == plugin_refs.end())
            plugin_refs.emplace_back(std::move(ref));
    };
 
    // Scalar options carry a single capability name; vector options carry a list. Same scalar/vector
    // dispatch as PluginResolver::find_option_for_capability.
    if (const auto* string_option = dynamic_cast<const ConfigOptionString*>(opt))
        append_ref(string_option->value);
    else if (const auto* vector_option = dynamic_cast<const ConfigOptionVectorBase*>(opt))
        for (const std::string& val : vector_option->vserialize())
            append_ref(val);
}

References def(), Slic3r::ConfigOptionDef::is_plugin_backed(), Slic3r::ConfigOptionDef::plugin_type, and resolve_capability_fn.

Referenced by collect_plugin_manifest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_to_json() [1/2]

void Slic3r::ConfigBase::save_to_json	(	const std::string &	file,
		const std::string &	name,
		const std::string &	from,
		const std::string &	version ) const

inherited

{
    // Serialize first: if that throws (invalid UTF-8), the existing file stays untouched.
    std::ostringstream ss;
    this->save_to_json(ss, name, from, version);
    if (const std::error_code ec = write_file_atomically(file, ss.str()))
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": failed to save config to %1%: %2%") % file % ec.message();
    else
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
}

References save_to_json(), and Slic3r::write_file_atomically().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_project_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_project_embedded_presets_to_archive(), Slic3r::PresetBundle::export_current_configs(), Slic3r::Preset::save(), and save_to_json().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_to_json() [2/2]

void Slic3r::ConfigBase::save_to_json	(	std::ostream &	os,
		const std::string &	name,
		const std::string &	from,
		const std::string &	version,
		bool	replace_invalid_utf8 = false ) const

inherited

{
    json j;
    //record the headers
    j[BBL_JSON_KEY_VERSION] = version;
    j[BBL_JSON_KEY_NAME] = name;
    j[BBL_JSON_KEY_FROM] = from;
 
    //record all the key-values
    for (const std::string &opt_key : this->keys())
    {
        const ConfigOption* opt = this->option(opt_key);
        if ( opt->is_scalar() ) {
            if (opt->type() == coString && (opt_key != "bed_custom_texture" && opt_key != "bed_custom_model"))
                //keep \n, \r, \t
                j[opt_key] = (dynamic_cast<const ConfigOptionString *>(opt))->value;
            else
                j[opt_key] = opt->serialize();
        }
        else {
            const ConfigOptionVectorBase* vec = static_cast<const ConfigOptionVectorBase*>(opt);
            //if (!vec->empty())
            std::vector<std::string> string_values = vec->vserialize();
 
            /*for (int i = 0; i < string_values.size(); i++)
            {
            std::string string_value = escape_string_cstyle(string_values[i]);
            j[opt_key][i] = string_value;
            }*/
 
            json j_array(string_values);
            j[opt_key] = j_array;
        }
    }
 
    // Serialize the top-level "plugins" manifest: the individual plugin-backed options keep bare
    // capability names; the full "name;uuid;capability" references are derived here (same helper as
    // update_plugin_manifest). Only with a resolver (GUI); without one (CLI/headless) leave whatever
    // the "plugins" option already serialized above, so a round-trip never drops the manifest.
    if (resolve_capability_fn) {
        std::vector<std::string> unique_refs = this->collect_plugin_manifest();
        if (unique_refs.empty())
            j.erase("plugins");
        else
            j["plugins"] = unique_refs;
    }
 
    os << j.dump(1, '\t', false, replace_invalid_utf8 ? json::error_handler_t::replace : json::error_handler_t::strict) << std::endl;
}

References BBL_JSON_KEY_FROM, BBL_JSON_KEY_NAME, BBL_JSON_KEY_VERSION, collect_plugin_manifest(), Slic3r::coString, keys(), option(), resolve_capability_fn, and Slic3r::ConfigOptionVectorBase::vserialize().

Here is the call graph for this function:

◆ set() [1/5]

void Slic3r::ConfigBase::set	(	const std::string &	opt_key,
		bool	value,
		bool	create = false )

inlineinherited

2823 { this->option_throw<ConfigOptionBool>(opt_key, create)->value = value; }

References option_throw().

Referenced by Slic3r::Print::apply(), Slic3r::extract_profile(), Slic3r::import_sla_archive(), Slic3r::CLI::run(), and Slic3r::GUI::CreatePrinterPresetDialog::save_printable_area_config().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set() [2/5]

void Slic3r::ConfigBase::set	(	const std::string &	opt_key,
		const char *	value,
		bool	create = false )

inlineinherited

2827 { this->option_throw<ConfigOptionString>(opt_key, create)->value = value; }

References option_throw().

Here is the call graph for this function:

◆ set() [3/5]

void Slic3r::ConfigBase::set	(	const std::string &	opt_key,
		const std::string &	value,
		bool	create = false )

inlineinherited

2829 { this->option_throw<ConfigOptionString>(opt_key, create)->value = value; }

References option_throw().

Here is the call graph for this function:

◆ set() [4/5]

void Slic3r::ConfigBase::set	(	const std::string &	opt_key,
		double	value,
		bool	create = false )

inherited

{
    ConfigOption *opt = this->option_throw(opt_key, create);
    switch (opt->type()) {
      case coFloat:       static_cast<ConfigOptionFloat*>(opt)->value = value; break;
      case coFloatOrPercent:  static_cast<ConfigOptionFloatOrPercent*>(opt)->value = value; static_cast<ConfigOptionFloatOrPercent*>(opt)->percent = false; break;
        case coString:      static_cast<ConfigOptionString*>(opt)->value = float_to_string_decimal_point(value); break;
      default: throw BadOptionTypeException("Configbase::set() - conversion from float not possible");
    }
}

References Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coString, Slic3r::float_to_string_decimal_point(), and option_throw().

Here is the call graph for this function:

◆ set() [5/5]

void Slic3r::ConfigBase::set	(	const std::string &	opt_key,
		int	value,
		bool	create = false )

inherited

{
    ConfigOption *opt = this->option_throw(opt_key, create);
    switch (opt->type()) {
      case coInt:    static_cast<ConfigOptionInt*>(opt)->value = value; break;
      case coFloat:  static_cast<ConfigOptionFloat*>(opt)->value = value; break;
    case coFloatOrPercent:  static_cast<ConfigOptionFloatOrPercent*>(opt)->value = value; static_cast<ConfigOptionFloatOrPercent*>(opt)->percent = false; break;
    case coString: static_cast<ConfigOptionString*>(opt)->value = std::to_string(value); break;
      default: throw BadOptionTypeException("Configbase::set() - conversion from int not possible");
    }
}

References Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coString, and option_throw().

Here is the call graph for this function:

◆ set_defaults()

void Slic3r::StaticConfig::set_defaults ( )

protected

Set all statically defined config options to their defaults defined by this->def().

{
    // use defaults from definition
    auto *defs = this->def();
    if (defs != nullptr) {
        for (const std::string &key : this->keys()) {
            const ConfigOptionDef   *def = defs->get(key);
            ConfigOption            *opt = this->option(key);
            if (def != nullptr && opt != nullptr && def->default_value)
                opt->set(def->default_value.get());
        }
    }
}

References Slic3r::ConfigBase::def(), keys(), and Slic3r::ConfigBase::option().

Here is the call graph for this function:

◆ set_deserialize() [1/2]

void Slic3r::ConfigBase::set_deserialize	(	const t_config_option_key &	opt_key,
		const std::string &	str,
		ConfigSubstitutionContext &	config_substitutions,
		bool	append = false )

inherited

{
  if (! this->set_deserialize_nothrow(opt_key_src, value_src, substitutions_ctxt, append))
    throw BadOptionValueException(format(_u8L("Invalid value provided for parameter %1%: %2%"), opt_key_src,  value_src));
}

References _u8L, Slic3r::append(), Slic3r::format(), and set_deserialize_nothrow().

Referenced by construct_assemble_list(), load(), load_from_gcode_file(), load_from_gcode_string_legacy(), load_from_json(), load_string_map(), set_deserialize(), set_deserialize_strict(), and set_deserialize_strict().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_deserialize() [2/2]

void Slic3r::ConfigBase::set_deserialize	(	std::initializer_list< SetDeserializeItem >	items,
		ConfigSubstitutionContext &	substitutions )

inherited

{
  for (const SetDeserializeItem &item : items)
    this->set_deserialize(item.opt_key, item.opt_value, substitutions_ctxt, item.append);
}

References set_deserialize().

Here is the call graph for this function:

◆ set_deserialize_nothrow()

bool Slic3r::ConfigBase::set_deserialize_nothrow	(	const t_config_option_key &	opt_key_src,
		const std::string &	value_src,
		ConfigSubstitutionContext &	substitutions,
		bool	append = false )

inherited

{
    t_config_option_key opt_key = opt_key_src;
    std::string         value   = value_src;
    // Both opt_key and value may be modified by handle_legacy().
    // If the opt_key is no more valid in this version of Slic3r, opt_key is cleared by handle_legacy().
    this->handle_legacy(opt_key, value);
    if (opt_key.empty()) {
        // Ignore the option.
        //BBS: record these options, keep only one repeated opt_key
        auto iter = std::find(substitutions_ctxt.unrecogized_keys.begin(), substitutions_ctxt.unrecogized_keys.end(), opt_key_src);
        if (iter == substitutions_ctxt.unrecogized_keys.end())
            substitutions_ctxt.unrecogized_keys.push_back(opt_key_src);
        return true;
    }
    return this->set_deserialize_raw(opt_key, value, substitutions_ctxt, append);
}

References Slic3r::append(), handle_legacy(), set_deserialize_raw(), and Slic3r::ConfigSubstitutionContext::unrecogized_keys.

Referenced by Slic3r::DynamicConfig::read_cli(), and set_deserialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_deserialize_raw()

bool Slic3r::ConfigBase::set_deserialize_raw	(	const t_config_option_key &	opt_key_src,
		const std::string &	value,
		ConfigSubstitutionContext &	substitutions,
		bool	append )

privateinherited

{
    t_config_option_key    opt_key = opt_key_src;
    // Try to deserialize the option by its name.
    const ConfigDef       *def     = this->def();
    if (def == nullptr)
        throw NoDefinitionException(opt_key);
    const ConfigOptionDef *optdef  = def->get(opt_key);
    if (optdef == nullptr) {
        // If we didn't find an option, look for any other option having this as an alias.
        for (const auto &opt : def->options) {
            for (const t_config_option_key &opt_key2 : opt.second.aliases) {
                if (opt_key2 == opt_key) {
                    opt_key = opt.first;
                    optdef = &opt.second;
                    break;
                }
            }
            if (optdef != nullptr)
                break;
        }
        if (optdef == nullptr)
            throw UnknownOptionException(opt_key);
    }
 
    if (! optdef->shortcut.empty()) {
        // Aliasing for example "solid_layers" to "top_shell_layers" and "bottom_shell_layers".
        for (const t_config_option_key &shortcut : optdef->shortcut)
            // Recursive call.
            if (! this->set_deserialize_raw(shortcut, value, substitutions_ctxt, append))
                return false;
        return true;
    }
 
    ConfigOption *opt = this->option(opt_key, true);
    assert(opt != nullptr);
    bool success     = false;
    bool substituted = false;
    if (optdef->type == coBools && substitutions_ctxt.rule != ForwardCompatibilitySubstitutionRule::Disable) {
        //FIXME Special handling of vectors of bools, quick and not so dirty solution before PrusaSlicer 2.3.2 release.
      bool nullable = opt->nullable();
      ConfigHelpers::DeserializationSubstitution default_value = ConfigHelpers::DeserializationSubstitution::DefaultsToFalse;
      if (optdef->default_value) {
        // Default value for vectors of booleans used in a "per extruder" context, thus the default contains just a single value.
        assert(dynamic_cast<const ConfigOptionVector<unsigned char>*>(optdef->default_value.get()));
      auto &values = static_cast<const ConfigOptionVector<unsigned char>*>(optdef->default_value.get())->values;
      if (values.size() == 1 && values.front() == 1)
        default_value = ConfigHelpers::DeserializationSubstitution::DefaultsToTrue;
    }
      auto result = nullable ?
        static_cast<ConfigOptionBoolsNullable*>(opt)->deserialize_with_substitutions(value, append, default_value) :
        static_cast<ConfigOptionBools*>(opt)->deserialize_with_substitutions(value, append, default_value);
      success     = result != ConfigHelpers::DeserializationResult::Failed;
      substituted = result == ConfigHelpers::DeserializationResult::Substituted;
    } else {
    //bool test = (opt_key == "filament_end_gcode");
    success = opt->deserialize(value, append);
      if (! success && substitutions_ctxt.rule != ForwardCompatibilitySubstitutionRule::Disable &&
          // Only allow substitutions of an enum value by another enum value or a boolean value with an enum value.
          // That means, we expect enum values being added in the future and possibly booleans being converted to enums.
            (optdef->type == coEnum || optdef->type == coEnums || optdef->type == coBool) /*&& ConfigHelpers::looks_like_enum_value(value)*/) {
          // Deserialize failed, try to substitute with a default value.
          //assert(substitutions_ctxt.rule == ForwardCompatibilitySubstitutionRule::Enable || substitutions_ctxt.rule == ForwardCompatibilitySubstitutionRule::EnableSilent);
          if (optdef->type == coBool)
              static_cast<ConfigOptionBool*>(opt)->value = ConfigHelpers::enum_looks_like_true_value(value);
          else
            // Just use the default of the option.
              opt->set(optdef->default_value.get());
            success     = true;
            substituted = true;
      }
  }
 
    if (substituted && (substitutions_ctxt.rule == ForwardCompatibilitySubstitutionRule::Enable ||
                        substitutions_ctxt.rule == ForwardCompatibilitySubstitutionRule::EnableSystemSilent)) {
        // Log the substitution.
        ConfigSubstitution config_substitution;
        config_substitution.opt_def   = optdef;
        config_substitution.old_value = value;
        config_substitution.new_value = ConfigOptionUniquePtr(opt->clone());
        substitutions_ctxt.substitutions.emplace_back(std::move(config_substitution));
    }
    return success;
}

References Slic3r::append(), Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coEnums, def(), Slic3r::ConfigOptionDef::default_value, Slic3r::ConfigHelpers::DefaultsToFalse, Slic3r::ConfigHelpers::DefaultsToTrue, Slic3r::Disable, Slic3r::Enable, Slic3r::EnableSystemSilent, Slic3r::ConfigHelpers::enum_looks_like_true_value(), Slic3r::ConfigHelpers::Failed, Slic3r::ConfigSubstitution::new_value, Slic3r::ConfigSubstitution::old_value, Slic3r::ConfigSubstitution::opt_def, option(), Slic3r::ConfigSubstitutionContext::rule, set_deserialize_raw(), Slic3r::ConfigOptionDef::shortcut, Slic3r::ConfigHelpers::Substituted, Slic3r::ConfigSubstitutionContext::substitutions, Slic3r::ConfigOptionDef::type, and Slic3r::ConfigOptionVector< T >::values.

Referenced by set_deserialize_nothrow(), and set_deserialize_raw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_deserialize_strict() [1/2]

void Slic3r::ConfigBase::set_deserialize_strict	(	const t_config_option_key &	opt_key,
		const std::string &	str,
		bool	append = false )

inlineinherited

2837 { ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Disable }; this->set_deserialize(opt_key, str, ctxt, append); }

References Slic3r::append(), Slic3r::Disable, and set_deserialize().

Referenced by Slic3r::GUI::Tab::apply_preset_config_values().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_deserialize_strict() [2/2]

void Slic3r::ConfigBase::set_deserialize_strict ( std::initializer_list< SetDeserializeItem > items )

inlineinherited

2854 { ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Disable }; this->set_deserialize(items, ctxt); }

References Slic3r::Disable, and set_deserialize().

Here is the call graph for this function:

◆ set_resolve_capability_fn()

void Slic3r::ConfigBase::set_resolve_capability_fn ( std::function< std::string(std::string, std::string)> fn )

inlinestaticinherited

2893{ resolve_capability_fn = fn; }

References resolve_capability_fn.

Referenced by Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_capability_resolver(), and Slic3r::plugin_hooks::uninstall().

Here is the caller graph for this function:

◆ setenv_()

void Slic3r::ConfigBase::setenv_ ( ) const

inherited

{
    t_config_option_keys opt_keys = this->keys();
    for (t_config_option_keys::const_iterator it = opt_keys.begin(); it != opt_keys.end(); ++it) {
        // prepend the SLIC3R_ prefix
        std::ostringstream ss;
        ss << "SLIC3R_";
        ss << *it;
        std::string envname = ss.str();
 
        // capitalize environment variable name
        for (size_t i = 0; i < envname.size(); ++i)
            envname[i] = (envname[i] <= 'z' && envname[i] >= 'a') ? envname[i]-('a'-'A') : envname[i];
 
        boost::nowide::setenv(envname.c_str(), this->opt_serialize(*it).c_str(), 1);
    }
}

References keys().

Referenced by Slic3r::run_post_process_scripts().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_plugin_manifest()

void Slic3r::ConfigBase::update_plugin_manifest ( )

inherited

{
    // Writes the derived manifest back into this config's "plugins" option (save_to_json writes the
    // same manifest into a JSON document instead), so an in-memory backend config carries a resolved
    // manifest even when the source preset was never serialized (picked-but-unsaved). Without a
    // resolver (CLI/headless) leave whatever manifest was loaded from disk untouched.
    if (!resolve_capability_fn)
        return;
    if (auto* manifest = this->option<ConfigOptionStrings>("plugins", true))
        manifest->values = this->collect_plugin_manifest();
}

References collect_plugin_manifest(), option(), and resolve_capability_fn.

Here is the call graph for this function:

Member Data Documentation

◆ resolve_capability_fn

std::function< std::string(std::string, std::string)> Slic3r::ConfigBase::resolve_capability_fn = nullptr

staticprivateinherited

Referenced by collect_plugin_manifest(), save_plugin_collection(), save_to_json(), set_resolve_capability_fn(), and update_plugin_manifest().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Config.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Config.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ StaticConfig()

Member Function Documentation

◆ apply()

◆ apply_only()

◆ apply_to()

◆ collect_plugin_manifest()

◆ def()

◆ diff()

◆ equal()

◆ equals()

◆ get_abs_value() [1/2]

◆ get_abs_value() [2/2]

◆ get_abs_value_at()

◆ handle_legacy()

◆ handle_legacy_composite()

◆ has()

◆ keys()

◆ load() [1/2]

◆ load() [2/2]

◆ load_from_gcode_file()

◆ load_from_gcode_string_legacy()

◆ load_from_ini()

◆ load_from_ini_string()

◆ load_from_ini_string_commented()

◆ load_from_json() [1/2]

◆ load_from_json() [2/2]

◆ load_string_map()

◆ null_nullables()

◆ opt_serialize()

◆ option() [1/3]

◆ option() [2/3]

◆ option() [3/3]

◆ option_throw() [1/3]

◆ option_throw() [2/3]

◆ option_throw() [3/3]

◆ optptr() [1/2]

◆ optptr() [2/2]

◆ save()

◆ save_plugin_collection()

◆ save_to_json() [1/2]

◆ save_to_json() [2/2]

◆ set() [1/5]

◆ set() [2/5]

◆ set() [3/5]

◆ set() [4/5]

◆ set() [5/5]

◆ set_defaults()

◆ set_deserialize() [1/2]

◆ set_deserialize() [2/2]

◆ set_deserialize_nothrow()

◆ set_deserialize_raw()

◆ set_deserialize_strict() [1/2]

◆ set_deserialize_strict() [2/2]

◆ set_resolve_capability_fn()

◆ setenv_()

◆ update_plugin_manifest()

Member Data Documentation

◆ resolve_capability_fn