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

Collaboration diagram for Slic3r::BundleMetadata:

Public Member Functions
bool	load_from_json (const std::string &path)
bool	save_to_json (const std::string &path) const

Public Attributes
std::string	id
std::string	name
std::string	version
std::string	description
std::string	author
long long	imported_time {0}
long long	updated_time {0}
BundleType	bundle_type {Default}
std::string	path
std::vector< std::string >	print_presets
std::vector< std::string >	filament_presets
std::vector< std::string >	printer_presets
bool	is_subscribed {false}
bool	update_available {false}
bool	not_found {false}
bool	unauthorized {false}

Detailed Description

Member Function Documentation

◆ load_from_json()

bool Slic3r::BundleMetadata::load_from_json ( const std::string & path )

{
    try {
        boost::nowide::ifstream ifs(path);
        if (!ifs.good())
            return false;
 
        json j;
        ifs >> j;
 
        if (j.contains("id")) this->id = j["id"].get<std::string>();
 
        if (j.contains("name")) this->name = j["name"].get<std::string>();
        else if (j.contains("bundle_id")) this->name = j["bundle_id"].get<std::string>();                 // backwards compat w bundle_structure.json
 
        if (j.contains("version")) this->version = j["version"].get<std::string>();
 
        if (j.contains("description")) this->description = j["description"].get<std::string>();
        else if (j.contains("bundle_type")) this->description = j["bundle_type"].get<std::string>();    // backwards compat w bundle_structure.json
 
        if (j.contains("author")) this->author = j["author"].get<std::string>();
 
        if (j.contains("imported_time")) this->imported_time = j["imported_time"].get<long long>();
 
        if (j.contains("updated_time")) this->updated_time = j["updated_time"].get<long long>();
 
        if (j.contains("print_presets"))                                                                                                                                                                                                                                      
            this->print_presets = j["print_presets"].get<std::vector<std::string>>();                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                
        if (j.contains("filament_presets"))                                                                                                                                                                                                                                   
            this->filament_presets = j["filament_presets"].get<std::vector<std::string>>();                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                
        if (j.contains("printer_presets"))                                                                                                                                                                                                                                    
            this->printer_presets = j["printer_presets"].get<std::vector<std::string>>();  
 
        return true;
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "Failed to load bundle metadata from " << path << ": " << e.what();
        return false;
    }
}

References author, description, filament_presets, imported_time, load_from_json(), name, path, print_presets, printer_presets, updated_time, and version.

Referenced by Slic3r::check_local_bundle(), Slic3r::PresetBundle::import_presets(), and load_from_json().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_to_json()

bool Slic3r::BundleMetadata::save_to_json ( const std::string & path ) const

{
    auto strip_prefix = [](const std::vector<std::string>& names) {
                json arr = json::array();
                for (const auto& name : names)
                {
                    arr.push_back(boost::filesystem::path(name).filename().string());
                    std::string test = boost::filesystem::path(name).filename().string();
                }
                return arr;
            };
    try {
        json j;
        j["id"] = this->id;
        j["name"] = this->name;
        j["version"] = this->version;
        j["description"] = this->description;
        j["author"] = this->author;
        j["imported_time"] = this->imported_time;
        j["updated_time"] = this->updated_time;
 
        j["print_presets"] = strip_prefix(this->print_presets);                                                                                                                                                                                                                             
        j["filament_presets"] = strip_prefix(this->filament_presets);                                                                                                                                                                                                                       
        j["printer_presets"] = strip_prefix(this->printer_presets);
 
        const std::string content = j.dump(4);
        InstanceLock instance_lock(user_presets_lock_path());
        if (const std::error_code ec = write_file_atomically(path, content)) {
            BOOST_LOG_TRIVIAL(error) << "Failed to save bundle metadata to " << path << ": " << ec.message();
            return false;
        }
        return true;
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "Failed to save bundle metadata to " << path << ": " << e.what();
        return false;
    }
}