#include <src/libslic3r/Format/SLAArchiveReader.hpp>

Inheritance diagram for Slic3r::SLAArchiveReader:

Public Member Functions
virtual	~SLAArchiveReader ()=default

virtual ConfigSubstitutions	read (std::vector< ExPolygons > &slices, DynamicPrintConfig &profile)=0

virtual ConfigSubstitutions	read (DynamicPrintConfig &profile)=0

Static Public Member Functions
static std::unique_ptr< SLAArchiveReader >	create (const std::string &fname, const std::string &format_id, SLAImportQuality quality=SLAImportQuality::Balanced, const ProgrFn &progr=[](int) { return false;})

Detailed Description

Constructor & Destructor Documentation

◆ ~SLAArchiveReader()

virtual Slic3r::SLAArchiveReader::~SLAArchiveReader ( )

virtualdefault

Member Function Documentation

◆ create()

std::unique_ptr< SLAArchiveReader > Slic3r::SLAArchiveReader::create	(	const std::string &	fname,
		const std::string &	format_id,
		SLAImportQuality	quality = `SLAImportQuality::Balanced`,
		const ProgrFn &	progr = `[](int) { return false; }`
	)

static

{
    // Create an instance of SLAArchiveReader using the registered archive
    // reader implementations.
    // If format_id is specified and valid, that archive format will be
    // preferred. When format_id is emtpy, the file extension is compared
    // with the advertised extensions of registered readers and the first
    // match will be used.
 
    std::string ext = boost::filesystem::path(fname).extension().string();
    boost::algorithm::to_lower(ext);
 
    std::unique_ptr<SLAArchiveReader> ret;
 
    auto registry = registered_sla_archives();
 
    auto arch_from = registry.begin();
    auto arch_to   = registry.end();
 
    auto arch_it = registry.find(ArchiveEntry{format_id.c_str()});
    if (arch_it != registry.end()) {
        arch_from = arch_it;
        arch_to   = arch_it;
    }
 
    if (!ext.empty()) {
        if (ext.front() == '.')
            ext.erase(ext.begin());
 
        for (auto it = arch_from; !ret && it != arch_to; ++it) {
            const auto &entry = *it;
            if (entry.rdfactoryfn) {
                auto extensions = get_extensions(entry);
                for (const std::string& supportedext : extensions) {
                    if (ext == supportedext) {
                        ret = entry.rdfactoryfn(fname, quality, progr);
                        break;
                    }
                }
            }
        }
    }
 
    return ret;
}