anonymous_namespace{profile_include_dump.cpp} Namespace Reference

Classes
struct	Entry

Typedefs
using	Sections = std::map<std::string, std::map<std::string, Entry>>

Functions
json	read_json (const fs::path &path)
Sections	read_vendor (const fs::path &dir, const std::string &vendor)
const PresetCollection &	presets_of (const PresetBundle &bundle, const std::string &section)
size_t	dump (const PresetBundle &bundle, const Sections &sections, std::ostream &out)
void	load_vendor (PresetBundle &bundle, const std::string &dir, const std::string &vendor, bool from_cache)

---

Class Documentation

anonymous_namespace{profile_include_dump.cpp}::Entry

struct anonymous_namespace{profile_include_dump.cpp}::Entry

Collaboration diagram for anonymous_namespace{profile_include_dump.cpp}::Entry:

Class Members
vector< string >	includes
string	inherits
vector< string >	keys

Typedef Documentation

Sections

using anonymous_namespace{profile_include_dump.cpp}::Sections = std::map<std::string, std::map<std::string, Entry>>

Function Documentation

dump()

size_t anonymous_namespace{profile_include_dump.cpp}::dump	(	const PresetBundle &	bundle,
		const Sections &	sections,
		std::ostream &	out )

{
    size_t dumped = 0;
    for (const auto &[section, entries] : sections) {
        std::vector<const Preset *> presets;
        for (const Preset &preset : presets_of(bundle, section).get_presets())
            if (preset.is_system)
                presets.push_back(&preset);
        std::sort(presets.begin(), presets.end(), [](const Preset *a, const Preset *b) { return a->name < b->name; });
        for (const Preset *preset : presets) {
            // The preset and its ancestors, root first: the order their includes apply in.
            std::vector<const Entry *> lineage;
            for (auto it = entries.find(preset->name); it != entries.end() && lineage.size() <= entries.size();
                 it = entries.find(it->second.inherits))
                lineage.insert(lineage.begin(), &it->second);
            std::string           templates;
            std::set<std::string> keys;
            for (const Entry *entry : lineage)
                for (const std::string &name : entry->includes) {
                    templates += (templates.empty() ? "" : "; ") + name;
                    if (const auto it = entries.find(name); it != entries.end())
                        keys.insert(it->second.keys.begin(), it->second.keys.end());
                }
            if (templates.empty())
                continue;
            const std::string prefix = section.substr(0, section.find('_')) + " | " + preset->name + " | ";
            out << prefix << "include = " << templates << "\n";
            for (const std::string &key : keys)
                out << prefix << key << " = " << (preset->config.has(key) ? preset->config.opt_serialize(key) : "<absent>") << "\n";
            ++dumped;
        }
    }
    return dumped;
}

References dump(), and presets_of().

Referenced by dump(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

load_vendor()

void anonymous_namespace{profile_include_dump.cpp}::load_vendor	(	PresetBundle &	bundle,
		const std::string &	dir,
		const std::string &	vendor,
		bool	from_cache )

{
    const auto          rule = ForwardCompatibilitySubstitutionRule::EnableSilent;
    PresetBundle        library;
    const PresetBundle *base = nullptr;
    if (fs::is_regular_file(fs::path(dir) / (std::string(PresetBundle::ORCA_FILAMENT_LIBRARY) + ".json"))) {
        library.load_vendor_configs_from_json(dir, PresetBundle::ORCA_FILAMENT_LIBRARY, PresetBundle::LoadSystem, rule, nullptr, false);
        base = &library;
    }
    if (!from_cache) {
        bundle.load_vendor_configs_from_json(dir, vendor, PresetBundle::LoadSystem, rule, base, false);
        return;
    }
    // Parse once to write <vendor>.opc beside the profile, then load that
    // cache into a clean bundle. Any cache already there goes first, so that a
    // failed write cannot leave it to be loaded; one that was not there before
    // goes again afterwards.
    const fs::path cache     = fs::path(dir) / (vendor + ".opc");
    const bool     had_cache = fs::exists(cache);
    fs::remove(cache);
    PresetBundle parsed;
    parsed.set_is_validation_mode(true); // parse the JSON: validation never serves a cache
    parsed.set_generate_vendor_caches(true);
    parsed.load_vendor_configs_from_json(dir, vendor, PresetBundle::LoadSystem, rule, base);
    const bool loaded = bundle.load_vendor_cache(cache.string(), vendor, parsed.vendors.at(vendor).config_version, base);
    if (!had_cache)
        fs::remove(cache);
    if (!loaded)
        throw std::runtime_error("The preset cache " + cache.string() + " was not written or was rejected");
}

References Slic3r::EnableSilent, load_vendor(), Slic3r::PresetBundle::load_vendor_cache(), Slic3r::PresetBundle::load_vendor_configs_from_json(), Slic3r::PresetBundle::LoadSystem, Slic3r::PresetBundle::ORCA_FILAMENT_LIBRARY, Slic3r::PresetBundle::set_generate_vendor_caches(), Slic3r::PresetBundle::set_is_validation_mode(), and Slic3r::PresetBundle::vendors.

Referenced by load_vendor(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

presets_of()

const PresetCollection & anonymous_namespace{profile_include_dump.cpp}::presets_of	(	const PresetBundle &	bundle,
		const std::string &	section )

{
    if (section == "process_list")
        return bundle.prints;
    if (section == "filament_list")
        return bundle.filaments;
    return bundle.printers;
}

References Slic3r::PresetBundle::filaments, presets_of(), Slic3r::PresetBundle::printers, and Slic3r::PresetBundle::prints.

Referenced by dump(), and presets_of().

Here is the call graph for this function:

Here is the caller graph for this function:

read_json()

json anonymous_namespace{profile_include_dump.cpp}::read_json

(

const fs::path &

path

)

{
    boost::nowide::ifstream in(path.string());
    if (!in)
        throw std::runtime_error("Cannot read " + path.string());
    return json::parse(in);
}

References read_json().

Referenced by read_json(), and read_vendor().

Here is the call graph for this function:

Here is the caller graph for this function:

read_vendor()

Sections anonymous_namespace{profile_include_dump.cpp}::read_vendor	(	const fs::path &	dir,
		const std::string &	vendor )

{
    // Keys that name and place a sub-file rather than set a value.
    static const std::set<std::string> metadata = {"name", "type", "from", "instantiation", "inherits", "include"};
    Sections   sections;
    const json index = read_json(dir / (vendor + ".json"));
    for (const char *section : {"process_list", "filament_list", "machine_list"}) {
        const auto list = index.find(section);
        if (list == index.end())
            continue;
        for (const json &item : *list) {
            const json file  = read_json(dir / vendor / item.at("sub_path").get<std::string>());
            // A file without a name goes by its name in the index.
            Entry     &entry = sections[section][file.value("name", item.at("name").get<std::string>())];
            entry.inherits   = file.value("inherits", "");
            if (const auto include = file.find("include"); include != file.end()) {
                if (include->is_string())
                    entry.includes.push_back(include->get<std::string>());
                else
                    for (const json &name : *include)
                        entry.includes.push_back(name.get<std::string>());
            }
            for (auto it = file.begin(); it != file.end(); ++it)
                if (metadata.count(it.key()) == 0)
                    entry.keys.push_back(it.key());
        }
    }
    return sections;
}

References anonymous_namespace{profile_include_dump.cpp}::Entry::includes, anonymous_namespace{profile_include_dump.cpp}::Entry::inherits, anonymous_namespace{profile_include_dump.cpp}::Entry::keys, read_json(), and read_vendor().

Referenced by main(), and read_vendor().

Here is the call graph for this function:

Here is the caller graph for this function: