Slic3r::Zipper Class Reference

#include <src/libslic3r/Zipper.hpp>

Collaboration diagram for Slic3r::Zipper:

Classes
class	Impl

Public Types
enum	e_compression { NO_COMPRESSION , FAST_COMPRESSION , TIGHT_COMPRESSION }

Public Member Functions
	Zipper (const std::string &zipfname, e_compression level=FAST_COMPRESSION)
	~Zipper ()
	Zipper (const Zipper &)=delete
Zipper &	operator= (const Zipper &)=delete
	Zipper (Zipper &&m)
Zipper &	operator= (Zipper &&m)
void	add_entry (const std::string &name)
	Adding an entry means a file inside the new archive. Name param is the name of the new file. To create directories, append a forward slash. The previous entry is finished (see finish_entry)
void	add_entry (const std::string &name, const void *data, size_t bytes)
	Add a new binary file entry with an instantly given byte buffer. This method throws exactly like finish_entry() does.
template<class T >
std::enable_if< std::is_arithmetic< T >::value, Zipper & >::type	operator<< (T &&val)
template<class T >
std::enable_if<!std::is_arithmetic< T >::value, Zipper & >::type	operator<< (T &&val)
void	finish_entry ()
	Finishing an entry means that subsequent writes will no longer be appended to the previous entry. They will be written into the internal buffer and ones an entry is added, the buffer will bind to the new entry If the buffer was written, but no entry was added, the buffer will be cleared after this call.
void	finalize ()
const std::string &	get_filename () const

Private Attributes
std::unique_ptr< Impl >	m_impl
std::string	m_data
std::string	m_entry
e_compression	m_compression

Detailed Description

Member Enumeration Documentation

e_compression

enum Slic3r::Zipper::e_compression

Enumerator
NO_COMPRESSION
FAST_COMPRESSION
TIGHT_COMPRESSION

                       {
        NO_COMPRESSION,
        FAST_COMPRESSION,
        TIGHT_COMPRESSION
    };

Constructor & Destructor Documentation

Zipper() [1/3]

Slic3r::Zipper::Zipper ( const std::string &  zipfname, e_compression  level = FAST_COMPRESSION  )

explicit

{
    m_impl.reset(new Impl());
 
    m_compression = compression;
    m_impl->m_zipname = zipfname;
 
    memset(&m_impl->arch, 0, sizeof(m_impl->arch));
 
    if (!open_zip_writer(&m_impl->arch, zipfname)) {
        m_impl->blow_up();
    }
}

References m_compression, m_impl, and Slic3r::open_zip_writer().

Here is the call graph for this function:

~Zipper()

Slic3r::Zipper::~Zipper

(

)

{
    if(m_impl->is_alive()) {
        // Flush the current entry if not finished yet.
        try { finish_entry(); } catch(...) {
            BOOST_LOG_TRIVIAL(error) << m_impl->formatted_errorstr();
        }
 
        if(!mz_zip_writer_finalize_archive(&m_impl->arch))
            BOOST_LOG_TRIVIAL(error) << m_impl->formatted_errorstr();
    }
 
    // The file should be closed no matter what...
    if(!close_zip_writer(&m_impl->arch))
        BOOST_LOG_TRIVIAL(error) << m_impl->formatted_errorstr();
}

References Slic3r::close_zip_writer(), error, finish_entry(), m_impl, and mz_zip_writer_finalize_archive().

Here is the call graph for this function:

Zipper() [2/3]

Slic3r::Zipper::Zipper ( const Zipper &  )

delete

Zipper() [3/3]

Slic3r::Zipper::Zipper

(

Zipper &&

m

)

                        :
    m_impl(std::move(m.m_impl)),
    m_data(std::move(m.m_data)),
    m_entry(std::move(m.m_entry)),
    m_compression(m.m_compression) {}

Member Function Documentation

add_entry() [1/2]

void Slic3r::Zipper::add_entry

(

const std::string &

name

)

Adding an entry means a file inside the new archive. Name param is the name of the new file. To create directories, append a forward slash. The previous entry is finished (see finish_entry)

{
    if(!m_impl->is_alive()) return;
 
    finish_entry(); // finish previous business
    m_entry = name;
}

References finish_entry(), m_entry, and m_impl.

Referenced by Slic3r::SL1Archive::export_print(), and Slic3r::write_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

add_entry() [2/2]

void Slic3r::Zipper::add_entry	(	const std::string &	name,
		const void *	data,
		size_t	bytes
	)

Add a new binary file entry with an instantly given byte buffer. This method throws exactly like finish_entry() does.

{
    if(!m_impl->is_alive()) return;
 
    finish_entry();
    mz_uint cmpr = MZ_NO_COMPRESSION;
    switch (m_compression) {
    case NO_COMPRESSION: cmpr = MZ_NO_COMPRESSION; break;
    case FAST_COMPRESSION: cmpr = MZ_BEST_SPEED; break;
    case TIGHT_COMPRESSION: cmpr = MZ_BEST_COMPRESSION; break;
    }
 
    if(!mz_zip_writer_add_mem(&m_impl->arch, name.c_str(), data, l, cmpr))
        m_impl->blow_up();
 
    m_entry.clear();
    m_data.clear();
}

References FAST_COMPRESSION, finish_entry(), m_compression, m_data, m_entry, m_impl, MZ_BEST_COMPRESSION, MZ_BEST_SPEED, MZ_NO_COMPRESSION, mz_zip_writer_add_mem(), NO_COMPRESSION, and TIGHT_COMPRESSION.

Here is the call graph for this function:

finalize()

void Slic3r::Zipper::finalize

(

)

{
    finish_entry();
 
    if(m_impl->is_alive()) if(!mz_zip_writer_finalize_archive(&m_impl->arch))
        m_impl->blow_up();
}

References finish_entry(), m_impl, and mz_zip_writer_finalize_archive().

Referenced by Slic3r::SL1Archive::export_print().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_entry()

void Slic3r::Zipper::finish_entry

(

)

Finishing an entry means that subsequent writes will no longer be appended to the previous entry. They will be written into the internal buffer and ones an entry is added, the buffer will bind to the new entry If the buffer was written, but no entry was added, the buffer will be cleared after this call.

This method will throw a runtime exception if an error occures. The entry will still be open (with the data intact) but the state of the file is up to minz after the erroneous write.

{
    if(!m_impl->is_alive()) return;
 
    if(!m_data.empty() && !m_entry.empty()) {
        mz_uint compression = MZ_NO_COMPRESSION;
 
        switch (m_compression) {
        case NO_COMPRESSION: compression = MZ_NO_COMPRESSION; break;
        case FAST_COMPRESSION: compression = MZ_BEST_SPEED; break;
        case TIGHT_COMPRESSION: compression = MZ_BEST_COMPRESSION; break;
        }
 
        if(!mz_zip_writer_add_mem(&m_impl->arch, m_entry.c_str(),
                                  m_data.c_str(),
                                  m_data.size(),
                                  compression)) m_impl->blow_up();
    }
 
    m_data.clear();
    m_entry.clear();
}

References FAST_COMPRESSION, m_compression, m_data, m_entry, m_impl, MZ_BEST_COMPRESSION, MZ_BEST_SPEED, MZ_NO_COMPRESSION, mz_zip_writer_add_mem(), NO_COMPRESSION, and TIGHT_COMPRESSION.

Referenced by ~Zipper(), add_entry(), add_entry(), and finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filename()

const std::string & Slic3r::Zipper::get_filename

(

)

const

{
    return m_impl->m_zipname;
}

References m_impl.

Referenced by Slic3r::SL1Archive::export_print().

Here is the caller graph for this function:

operator<<() [1/2]

template<class T >

std::enable_if< std::is_arithmetic< T >::value, Zipper & >::type Slic3r::Zipper::operator<< ( T &&  val )

inline

                        {
        return this->operator<<(std::to_string(std::forward<T>(val)));
    }

operator<<() [2/2]

template<class T >

std::enable_if<!std::is_arithmetic< T >::value, Zipper & >::type Slic3r::Zipper::operator<< ( T &&  val )

inline

                        {
        if(m_data.empty()) m_data = std::forward<T>(val);
        else m_data.append(val);
        return *this;
    }

References m_data.

operator=() [1/2]

Zipper & Slic3r::Zipper::operator= ( const Zipper &  )

delete

operator=() [2/2]

Zipper & Slic3r::Zipper::operator=

(

Zipper &&

m

)

                                    {
    m_impl = std::move(m.m_impl);
    m_data = std::move(m.m_data);
    m_entry = std::move(m.m_entry);
    m_compression = m.m_compression;
    return *this;
}

References m_compression, m_data, m_entry, and m_impl.

Member Data Documentation

m_compression

e_compression Slic3r::Zipper::m_compression

private

Referenced by Zipper(), add_entry(), finish_entry(), and operator=().

m_data

std::string Slic3r::Zipper::m_data

private

Referenced by add_entry(), finish_entry(), operator<<(), and operator=().

m_entry

std::string Slic3r::Zipper::m_entry

private

Referenced by add_entry(), add_entry(), finish_entry(), and operator=().

m_impl

std::unique_ptr<Impl> Slic3r::Zipper::m_impl

private

Referenced by Zipper(), ~Zipper(), add_entry(), add_entry(), finalize(), finish_entry(), get_filename(), and operator=().

---

The documentation for this class was generated from the following files:

• src/libslic3r/Zipper.hpp
• src/libslic3r/Zipper.cpp