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

Collaboration diagram for Slic3r::GUI::Snapshot:

Classes
struct	VendorConfig

Public Types
enum	Reason { SNAPSHOT_UNKNOWN , SNAPSHOT_UPGRADE , SNAPSHOT_DOWNGRADE , SNAPSHOT_BEFORE_ROLLBACK , SNAPSHOT_USER }

Public Member Functions
	Snapshot ()
void	clear ()
void	load_ini (const std::string &path)
void	save_ini (const std::string &path)
void	export_selections (AppConfig &config) const
void	export_vendor_configs (AppConfig &config) const
bool	equal_to_active (const AppConfig &app_config) const
std::string	format_reason () const

Public Attributes
std::string	id
std::time_t	time_captured
Semver	slic3r_version_captured = Semver::invalid()
std::string	comment
Reason	reason
std::string	print
std::string	sla_print
std::vector< std::string >	filaments
std::string	sla_material
std::string	printer
std::string	physical_printer
std::vector< VendorConfig >	vendor_configs

Detailed Description

Class Documentation

◆ Slic3r::GUI::Snapshot::VendorConfig

struct Slic3r::GUI::Snapshot::VendorConfig

Collaboration diagram for Slic3r::GUI::Snapshot::VendorConfig:

Class Members
map< string, set< string > >	models_variants_installed
string	name
Version	version

Member Enumeration Documentation

◆ Reason

enum Slic3r::GUI::Config::Snapshot::Reason

Enumerator
SNAPSHOT_UNKNOWN
SNAPSHOT_UPGRADE
SNAPSHOT_DOWNGRADE
SNAPSHOT_BEFORE_ROLLBACK
SNAPSHOT_USER

              {
    SNAPSHOT_UNKNOWN,
    SNAPSHOT_UPGRADE,
    SNAPSHOT_DOWNGRADE,
    SNAPSHOT_BEFORE_ROLLBACK,
    SNAPSHOT_USER,
  };

Constructor & Destructor Documentation

◆ Snapshot()

Slic3r::GUI::Config::Snapshot::Snapshot ( )

inline

44{ clear(); }

Slic3r::GUI::Config::Snapshot::clear

void clear()

Definition Snapshot.cpp:57

Member Function Documentation

◆ clear()

void Slic3r::GUI::Config::Snapshot::clear ( )

{
  this->id.clear();
  this->time_captured = 0;
  this->slic3r_version_captured = Semver::invalid();
  this->comment.clear();
  this->reason = SNAPSHOT_UNKNOWN;
  this->print.clear();
    this->sla_print.clear();
  this->filaments.clear();
    this->sla_material.clear();
  this->printer.clear();
    this->physical_printer.clear();
}

◆ equal_to_active()

bool Slic3r::GUI::Config::Snapshot::equal_to_active ( const AppConfig & app_config ) const

{
    // 1) Check, whether this snapshot contains the same set of active vendors, printer models and variants
    // as app_config.
    {
        std::set<std::string> matched;
        for (const VendorConfig &vc : this->vendor_configs) {
            auto it_vendor_models_variants = app_config.vendors().find(vc.name);
            if (it_vendor_models_variants == app_config.vendors().end() ||
                it_vendor_models_variants->second != vc.models_variants_installed)
                // There are more vendors enabled in the snapshot than currently installed.
                return false;
            matched.insert(vc.name);
        }
        for (const auto &v : app_config.vendors())
            if (matched.find(v.first) == matched.end() && ! v.second.empty())
                // There are more vendors currently installed than enabled in the snapshot.
                return false;
    }
 
    // 2) Check, whether this snapshot references the same set of ini files as the current state.
    boost::filesystem::path data_dir     = boost::filesystem::path(Slic3r::data_dir());
    boost::filesystem::path snapshot_dir = boost::filesystem::path(Slic3r::data_dir()) / SLIC3R_SNAPSHOTS_DIR / this->id;
    for (const char *subdir : snapshot_subdirs) {
        boost::filesystem::path path1 = data_dir / subdir;
        boost::filesystem::path path2 = snapshot_dir / subdir;
        std::vector<std::string> files1, files2;
        if (boost::filesystem::is_directory(path1))
            for (auto &dir_entry : boost::filesystem::directory_iterator(path1))
                if (Slic3r::is_ini_file(dir_entry))
                    files1.emplace_back(dir_entry.path().filename().string());
        if (boost::filesystem::is_directory(path2))
            for (auto &dir_entry : boost::filesystem::directory_iterator(path2))
                if (Slic3r::is_ini_file(dir_entry))
                    files2.emplace_back(dir_entry.path().filename().string());
        std::sort(files1.begin(), files1.end());
        std::sort(files2.begin(), files2.end());
        if (files1 != files2)
            return false;
        for (const std::string &filename : files1) {
            FILE *f1 = boost::nowide::fopen((path1 / filename).string().c_str(), "rb");
            FILE *f2 = boost::nowide::fopen((path2 / filename).string().c_str(), "rb");
            bool same = true;
            if (f1 && f2) {
                char buf1[4096];
                char buf2[4096];
                do {
                    size_t r1 = fread(buf1, 1, 4096, f1);
                    size_t r2 = fread(buf2, 1, 4096, f2);
                    if (r1 != r2 || memcmp(buf1, buf2, r1)) {
                        same = false;
                        break;
                    }
                } while (! feof(f1) || ! feof(f2));
            } else
                same = false;
            if (f1)
                fclose(f1);
            if (f2)
                fclose(f2);
            if (! same)
                return false;
        }
    }
    return true;
}

◆ export_selections()

void Slic3r::GUI::Config::Snapshot::export_selections ( AppConfig & config ) const

{
    assert(filaments.size() >= 1);
    config.clear_section("presets");
    config.set("presets", PRESET_PRINT_NAME,     print);
    config.set("presets", "sla_print", sla_print);
    config.set("presets", PRESET_FILAMENT_NAME,  filaments.front());
    for (unsigned i = 1; i < filaments.size(); ++i) {
        char name[64];
        sprintf(name, "filament_%u", i);
        config.set("presets", name, filaments[i]);
    }
    config.set("presets", "sla_material",     sla_material);
    config.set("presets", PRESET_PRINTER_NAME,          printer);
    config.set("presets", "physical_printer", physical_printer);
}

◆ export_vendor_configs()

void Slic3r::GUI::Config::Snapshot::export_vendor_configs ( AppConfig & config ) const

{
    std::map<std::string, std::map<std::string, std::set<std::string>>> vendors;
    for (const VendorConfig &vc : vendor_configs)
        vendors[vc.name] = vc.models_variants_installed;
    config.set_vendors(std::move(vendors));
}

◆ format_reason()

std::string Slic3r::GUI::Config::Snapshot::format_reason ( ) const

◆ load_ini()

void Slic3r::GUI::Config::Snapshot::load_ini ( const std::string & path )

{
  this->clear();
 
  auto throw_on_parse_error = [&path](const std::string &msg) {
    throw file_parser_error(std::string("Failed loading the snapshot file. Reason: ") + msg, path);
  };
 
  // Load the snapshot.ini file.
    boost::property_tree::ptree tree;
    try {
        boost::nowide::ifstream ifs(path);
        boost::property_tree::read_ini(ifs, tree);
    } catch (const std::ifstream::failure &err) {
        throw file_parser_error(std::string("The snapshot file cannot be loaded. Reason: ") + err.what(), path);
    } catch (const std::runtime_error &err) {
        throw_on_parse_error(err.what());
    }
 
    // Parse snapshot.ini
    std::string group_name_vendor = "Vendor:";
  std::string key_filament = "filament";
    std::string key_prefix_model = "model_";
    for (auto &section : tree) {
      if (section.first == "snapshot") {
        // Parse the common section.
            for (auto &kvp : section.second) {
                if (kvp.first == "id")
                    this->id = kvp.second.data();
                else if (kvp.first == "time_captured") {
                  this->time_captured = Slic3r::Utils::parse_iso_utc_timestamp(kvp.second.data());
          if (this->time_captured == (time_t)-1)
                throw_on_parse_error("invalid timestamp");
                } else if (kvp.first == "slic3r_version_captured") {
                  auto semver = Semver::parse(kvp.second.data());
                  if (! semver)
                    throw_on_parse_error("invalid slic3r_version_captured semver");
                  this->slic3r_version_captured = *semver;
                } else if (kvp.first == "comment") {
                  this->comment = kvp.second.data();
                } else if (kvp.first == "reason") {
                  std::string rsn = kvp.second.data();
                  if (rsn == "upgrade")
                    this->reason = SNAPSHOT_UPGRADE;
                  else if (rsn == "downgrade")
                    this->reason = SNAPSHOT_DOWNGRADE;
                    else if (rsn == "before_rollback")
                        this->reason = SNAPSHOT_BEFORE_ROLLBACK;
                  else if (rsn == "user")
                    this->reason = SNAPSHOT_USER;
                  else
                    this->reason = SNAPSHOT_UNKNOWN;
                }
            }
      } else if (section.first == "presets") {
            // Load the names of the active presets.
            for (auto &kvp : section.second) {
                if (kvp.first == PRESET_PRINT_NAME) {
                    this->print = kvp.second.data();
                } else if (kvp.first == "sla_print") {
                    this->sla_print = kvp.second.data();
                } else if (boost::starts_with(kvp.first, PRESET_FILAMENT_NAME)) {
                    int idx = 0;
                    if (kvp.first == "filament" || sscanf(kvp.first.c_str(), "filament_%d", &idx) == 1) {
                        if (int(this->filaments.size()) <= idx)
                            this->filaments.resize(idx + 1, std::string());
                        this->filaments[idx] = kvp.second.data();
                    }
                } else if (kvp.first == "sla_material") {
                    this->sla_material = kvp.second.data();
                } else if (kvp.first == PRESET_PRINTER_NAME) {
                    this->printer = kvp.second.data();
                } else if (kvp.first == "physical_printer") {
                    this->physical_printer = kvp.second.data();
                }
            }
      } else if (boost::starts_with(section.first, group_name_vendor) && section.first.size() > group_name_vendor.size()) {
        // Vendor specific section.
            VendorConfig vc;
            vc.name = section.first.substr(group_name_vendor.size());
            for (auto &kvp : section.second) {
              if (kvp.first == "version" || kvp.first == "min_slic3r_version" || kvp.first == "max_slic3r_version") {
                // Version of the vendor specific config bundle bundled with this snapshot.
                  auto semver = Semver::parse(kvp.second.data());
                  if (! semver)
                    throw_on_parse_error("invalid " + kvp.first + " format for " + section.first);
          if (kvp.first == "version")
                    vc.version.config_version = *semver;
                  else if (kvp.first == "min_slic3r_version")
                    vc.version.min_slic3r_version = *semver;
                  else
                    vc.version.max_slic3r_version = *semver;
              } else if (boost::starts_with(kvp.first, key_prefix_model) && kvp.first.size() > key_prefix_model.size()) {
                    // Parse the printer variants installed for the current model.
                    auto &set_variants = vc.models_variants_installed[kvp.first.substr(key_prefix_model.size())];
                    std::vector<std::string> variants;
                    if (unescape_strings_cstyle(kvp.second.data(), variants))
                        for (auto &variant : variants)
                            set_variants.insert(std::move(variant));
                }
      }
      this->vendor_configs.emplace_back(std::move(vc));
        }
    }
    // Sort the vendors lexicographically.
    std::sort(this->vendor_configs.begin(), this->vendor_configs.begin(),
        [](const VendorConfig &cfg1, const VendorConfig &cfg2) { return cfg1.name < cfg2.name; });
}

◆ save_ini()

void Slic3r::GUI::Config::Snapshot::save_ini ( const std::string & path )

{
  boost::nowide::ofstream c;
    c.open(path, std::ios::out | std::ios::trunc);
    c << "# " << Slic3r::header_slic3r_generated() << std::endl;
 
    // Export the common "snapshot".
  c << std::endl << "[snapshot]" << std::endl;
  c << "id = " << this->id << std::endl;
  c << "time_captured = " << Slic3r::Utils::iso_utc_timestamp(this->time_captured) << std::endl;
  c << "slic3r_version_captured = " << this->slic3r_version_captured.to_string() << std::endl;
  c << "comment = " << this->comment << std::endl;
  c << "reason = " << reason_string(this->reason) << std::endl;
 
    // Export the active presets at the time of the snapshot.
  c << std::endl << "[presets]" << std::endl;
  c << "print = " << this->print << std::endl;
    c << "sla_print = " << this->sla_print << std::endl;
  c << "filament = " << this->filaments.front() << std::endl;
  for (size_t i = 1; i < this->filaments.size(); ++ i)
    c << "filament_" << std::to_string(i) << " = " << this->filaments[i] << std::endl;
    c << "sla_material = " << this->sla_material << std::endl;
  c << "printer = " << this->printer << std::endl;
    c << "physical_printer = " << this->physical_printer << std::endl;
 
    // Export the vendor configs.
    for (const VendorConfig &vc : this->vendor_configs) {
    c << std::endl << "[Vendor:" << vc.name << "]" << std::endl;
    c << "version = " << vc.version.config_version.to_string() << std::endl;
    c << "min_slic3r_version = " << vc.version.min_slic3r_version.to_string() << std::endl;
    c << "max_slic3r_version = " << vc.version.max_slic3r_version.to_string() << std::endl;
        // Export installed printer models and their variants.
        for (const auto &model : vc.models_variants_installed) {
            if (model.second.size() == 0)
                continue;
            const std::vector<std::string> variants(model.second.begin(), model.second.end());
            const auto escaped = escape_strings_cstyle(variants);
            c << "model_" << model.first << " = " << escaped << std::endl;
        }
    }
    c.close();
}