Slic3r::anonymous_namespace{PresetCacheFormat.cpp} Namespace Reference

Classes
struct	CacheFileHeader

Functions
std::string	read_bounded_string (cereal::BinaryInputArchive &ar)
std::string	read_cache_stamps (cereal::BinaryInputArchive &ar, const std::string &expected_vendor_name)
bool	cache_covers_version (const std::string &cached, const Semver &on_disk)
template<class Archive, class Entry, class ConfigFn>
void	visit_entry (Archive &ar, Entry &e, ConfigFn &&config)
void	save_entries (cereal::BinaryOutputArchive &ar, const std::vector< CachedPreset > &entries, const CacheDictionary &dict)
void	load_entries (cereal::BinaryInputArchive &ar, std::vector< CachedPreset > &entries, const CacheDictionary &dict)
bool	read_cache_blob (const std::string &path, std::string &out_blob)
bool	write_cache_blob (const std::string &path, const std::string &blob)

Variables
constexpr uint32_t	CACHE_MAGIC = 0x4F52435A
constexpr uint32_t	CACHE_VERSION = 2
constexpr uint32_t	MAX_RESERVED_ENTRIES = 4096

---

Class Documentation

Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader

struct Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader

Class Members
uint32_t	crc32
uint64_t	data_size
uint32_t	magic
uint32_t	version

Function Documentation

cache_covers_version()

bool Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::cache_covers_version	(	const std::string &	cached,
		const Semver &	on_disk )

{
    if (on_disk == Semver::inf())
        return true;    // before parsing `cached`: nothing exists that the stamp must cover
    if (! on_disk.valid())
        return false;
    const auto cached_ver = Semver::parse(cached);
    return cached_ver && *cached_ver >= on_disk;
}

References cache_covers_version(), Slic3r::Semver::inf(), Slic3r::Semver::parse(), and Slic3r::Semver::valid().

Referenced by cache_covers_version().

Here is the call graph for this function:

Here is the caller graph for this function:

load_entries()

void Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::load_entries	(	cereal::BinaryInputArchive &	ar,
		std::vector< CachedPreset > &	entries,
		const CacheDictionary &	dict )

{
    uint32_t cnt = 0;
    ar(cnt);
    entries.clear();
    entries.reserve(std::min(cnt, MAX_RESERVED_ENTRIES));
    for (uint32_t i = 0; i < cnt; ++ i) {
        CachedPreset e;
        visit_entry(ar, e, [&] { load_config(ar, e.config_src, dict); });
        entries.push_back(std::move(e));
    }
}

References Slic3r::CachedPreset::config_src, Slic3r::load_config(), load_entries(), MAX_RESERVED_ENTRIES, and visit_entry().

Referenced by load_entries().

Here is the call graph for this function:

Here is the caller graph for this function:

read_bounded_string()

std::string Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::read_bounded_string

(

cereal::BinaryInputArchive &

ar

)

{
    constexpr uint64_t MAX_STAMP_LEN = 1024;
    cereal::size_type len = 0;
    ar(cereal::make_size_tag(len));
    if (uint64_t(len) > MAX_STAMP_LEN)
        throw std::runtime_error("preset cache: string length out of bounds");
    std::string s(size_t(len), '\0');
    ar(cereal::binary_data(s.data(), size_t(len)));
    return s;
}

References read_bounded_string().

Referenced by read_bounded_string(), and read_cache_stamps().

Here is the call graph for this function:

Here is the caller graph for this function:

read_cache_blob()

bool Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::read_cache_blob	(	const std::string &	path,
		std::string &	out_blob )

{
    try {
        boost::nowide::ifstream ifs(path, std::ios::binary);
        if (!ifs.is_open())
            return false;
        CacheFileHeader fhdr;
        if (!ifs.read(reinterpret_cast<char*>(&fhdr), sizeof(fhdr)))
            return false;
        if (fhdr.magic != CACHE_MAGIC)
            return false;
        // data_size is 8 bytes from a file nothing has authenticated yet, and
        // it is about to size an allocation. The body is the whole of the file
        // behind the header — anything else is not a cache this build wrote.
        ifs.seekg(0, std::ios::end);
        const std::streamoff file_size = ifs.tellg();
        if (file_size < std::streamoff(sizeof(fhdr)) ||
            fhdr.data_size == 0 ||
            fhdr.data_size != uint64_t(file_size) - sizeof(fhdr))
            return false;
        ifs.seekg(sizeof(fhdr), std::ios::beg);
        out_blob.assign(fhdr.data_size, '\0');
        if (!ifs.read(&out_blob[0], static_cast<std::streamsize>(fhdr.data_size)))
            return false;
        boost::crc_32_type crc;
        crc.process_bytes(out_blob.data(), out_blob.size());
        if (crc.checksum() != fhdr.crc32) {
            BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: CRC mismatch: " << path;
            return false;
        }
        return true;
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: read failed (" << path << "): " << e.what();
        return false;
    }
}

References CACHE_MAGIC, Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader::crc32, Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader::data_size, Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader::magic, and read_cache_blob().

Referenced by read_cache_blob().

Here is the call graph for this function:

Here is the caller graph for this function:

read_cache_stamps()

std::string Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::read_cache_stamps	(	cereal::BinaryInputArchive &	ar,
		const std::string &	expected_vendor_name )

{
    // The version is judged before anything variable-length is read: on a body
    // that is not a per-vendor cache of this version, the bytes where a string
    // length would sit may be arbitrary framing.
    uint32_t cache_version = 0;
    ar(cache_version);
    if (cache_version != CACHE_VERSION)
        return {};
    const std::string vendor_name    = read_bounded_string(ar);
    const std::string vendor_version = read_bounded_string(ar);
    if (vendor_name != expected_vendor_name)
        return {};
    return vendor_version;
}

References CACHE_VERSION, read_bounded_string(), and read_cache_stamps().

Referenced by read_cache_stamps().

Here is the call graph for this function:

Here is the caller graph for this function:

save_entries()

void Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::save_entries	(	cereal::BinaryOutputArchive &	ar,
		const std::vector< CachedPreset > &	entries,
		const CacheDictionary &	dict )

{
    ar(uint32_t(entries.size()));
    for (const CachedPreset& e : entries)
        visit_entry(ar, e, [&] { save_config(ar, e.config_src, dict); });
}

References Slic3r::save_config(), save_entries(), and visit_entry().

Referenced by save_entries().

Here is the call graph for this function:

Here is the caller graph for this function:

visit_entry()

template<class Archive, class Entry, class ConfigFn>

void Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::visit_entry	(	Archive &	ar,
		Entry &	e,
		ConfigFn &&	config )

{
    ar(e.name, e.sub_path);
    config();
    ar(e.inherits, e.includes, e.description, e.instantiation, e.setting_id, e.filament_id, e.renamed_from);
}

References visit_entry().

Referenced by load_entries(), save_entries(), and visit_entry().

Here is the call graph for this function:

Here is the caller graph for this function:

write_cache_blob()

bool Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::write_cache_blob	(	const std::string &	path,
		const std::string &	blob )

{
    boost::crc_32_type crc;
    crc.process_bytes(blob.data(), blob.size());
    // Written beside the target and moved into place: a cache is truncated and
    // rewritten in full, so a write that dies partway would otherwise leave a
    // header claiming more body than the file holds.
    try {
        boost::filesystem::create_directories(boost::filesystem::path(path).parent_path());
        CacheFileHeader fhdr;
        fhdr.magic     = CACHE_MAGIC;
        fhdr.version   = CACHE_VERSION;
        fhdr.data_size = static_cast<uint64_t>(blob.size());
        fhdr.crc32     = crc.checksum();
        const std::string_view header(reinterpret_cast<const char*>(&fhdr), sizeof(fhdr));
        if (const std::error_code ec = write_file_atomically(path, { header, std::string_view(blob) }, /*binary=*/true)) {
            BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << path << "): " << ec.message();
            return false;
        }
        return true;
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << path << "): " << e.what();
        return false;
    }
}

References CACHE_MAGIC, CACHE_VERSION, Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader::crc32, Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader::data_size, Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader::magic, Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CacheFileHeader::version, write_cache_blob(), and Slic3r::write_file_atomically().

Referenced by write_cache_blob().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CACHE_MAGIC

uint32_t Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CACHE_MAGIC = 0x4F52435A

constexpr

Referenced by read_cache_blob(), and write_cache_blob().

CACHE_VERSION

uint32_t Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::CACHE_VERSION = 2

constexpr

Referenced by read_cache_stamps(), and write_cache_blob().

MAX_RESERVED_ENTRIES

uint32_t Slic3r::anonymous_namespace{PresetCacheFormat.cpp}::MAX_RESERVED_ENTRIES = 4096

constexpr

Referenced by load_entries().