Slic3r::_BBS_Backup_Manager Class Reference

Collaboration diagram for Slic3r::_BBS_Backup_Manager:

Classes
struct	Task
struct	timer
union	Task.__unnamed0__

Public Member Functions
void	set_post_callback (std::function< void(int)> c)
void	run_ui_tasks ()
void	push_object_gaurd (ModelObject &object)
void	pop_object_gaurd ()
void	add_object_mesh (ModelObject &object)
void	remove_object_mesh (ModelObject &object)
void	backup_soon ()
void	remove_backup (Model &model, bool removeAll)
void	set_interval (long n)
void	put_other_changes ()
void	clear_other_changes (bool backup)
bool	has_other_changes (bool backup)
void	operator() ()
bool	delay_task (Task &t, boost::unique_lock< boost::mutex > &lock)

Static Public Member Functions
static _BBS_Backup_Manager &	get ()

Private Types
enum	TaskType {   None , Backup , AddObject , RemoveObject ,   RemoveBackup , Exit }

Private Member Functions
	_BBS_Backup_Manager ()
	~_BBS_Backup_Manager ()
void	push_task (Task const &t)
void	process_ui_task (Task &t, bool canceled=false)
void	process_task (Task &t)

Private Attributes
boost::mutex	m_mutex
boost::condition_variable	m_cond
std::deque< Task >	m_tasks
std::deque< Task >	m_ui_tasks
size_t	m_task_seq = 0
std::function< void(int)>	m_post_callback
long	m_interval = 1 * 60
boost::system_time	m_next_backup
Model	m_temp_model
bool	m_other_changes = false
bool	m_other_changes_backup = false
std::vector< std::pair< ModelObject *, size_t > >	m_gaurd_objects
boost::thread	m_thread

Detailed Description

---

Class Documentation

Slic3r::_BBS_Backup_Manager::Task.__unnamed0__

union Slic3r::_BBS_Backup_Manager::Task.__unnamed0__

Class Members
size_t	delay
bool	removeAll
size_t	sequence

Member Enumeration Documentation

TaskType

enum Slic3r::_BBS_Backup_Manager::TaskType

private

Enumerator
None
Backup
AddObject
RemoveObject
RemoveBackup
Exit

                  {
        None,
        Backup, // this task is working as response in ui thread
        AddObject,
        RemoveObject,
        RemoveBackup,
        Exit
    };

Constructor & Destructor Documentation

_BBS_Backup_Manager()

Slic3r::_BBS_Backup_Manager::_BBS_Backup_Manager ( )

inlineprivate

                          {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " inital and interval = " << m_interval;
        m_next_backup = boost::get_system_time() + boost::posix_time::seconds(m_interval);
        boost::unique_lock lock(m_mutex);
        m_thread = boost::thread(boost::ref(*this));
    }

References m_interval, m_mutex, m_next_backup, and m_thread.

Referenced by get().

Here is the caller graph for this function:

~_BBS_Backup_Manager()

Slic3r::_BBS_Backup_Manager::~_BBS_Backup_Manager ( )

inlineprivate

                           {
        push_task({Exit});
        m_thread.join();
    }

References Exit, m_thread, and push_task().

Here is the call graph for this function:

Member Function Documentation

add_object_mesh()

void Slic3r::_BBS_Backup_Manager::add_object_mesh ( ModelObject & object )

inline

                                              {
        for (auto& g : m_gaurd_objects) {
            if (g.first == &object) {
                ++g.second;
                return;
            }
        }
        // clone object
        auto model = object.get_model();
        auto o = m_temp_model.add_object(object);
        int backup_id = model->get_object_backup_id(object);
        push_task({ AddObject, (size_t) backup_id, object.get_model()->get_backup_path(), o, { 1 } });
    }

References AddObject, m_gaurd_objects, m_temp_model, and push_task().

Referenced by pop_object_gaurd().

Here is the call graph for this function:

Here is the caller graph for this function:

backup_soon()

void Slic3r::_BBS_Backup_Manager::backup_soon ( )

inline

                       {
        boost::lock_guard lock(m_mutex);
        m_other_changes_backup = true;
        m_tasks.push_back({ Backup, 0, std::string(), nullptr, { ++m_task_seq } });
        m_cond.notify_all();
    }

References Backup, m_cond, m_mutex, m_other_changes_backup, m_task_seq, and m_tasks.

clear_other_changes()

void Slic3r::_BBS_Backup_Manager::clear_other_changes ( bool backup )

inline

    {
        if (backup)
            m_other_changes_backup = false;
        else
            m_other_changes = false;
    }

References m_other_changes, and m_other_changes_backup.

delay_task()

bool Slic3r::_BBS_Backup_Manager::delay_task ( Task & t, boost::unique_lock< boost::mutex > & lock )

inline

                                                                  {
        // delay last task for 3 seconds after last modify
        auto now = boost::get_system_time();
        auto delay_expire = now + boost::posix_time::seconds(10); // must not delay over this time
        auto wait = now + boost::posix_time::seconds(3);
        while (true) {
            m_cond.timed_wait(lock, wait);
            // Only delay when it's the only-one task
            if (m_tasks.size() != 1 || m_tasks.front().delay == t.delay)
                break;
            t.delay = m_tasks.front().delay;
            now = boost::get_system_time();
            if (now >= delay_expire)
                break;
            wait = now + boost::posix_time::seconds(3);
            if (wait > delay_expire)
                wait = delay_expire;
        };
        // task maybe canceled
        if (m_tasks.empty())
            return false;
        t = m_tasks.front();
        return true;
    }

References m_cond, and m_tasks.

Referenced by operator()().

Here is the caller graph for this function:

get()

_BBS_Backup_Manager & Slic3r::_BBS_Backup_Manager::get ( )

inlinestatic

                                      {
        static _BBS_Backup_Manager m;
        return m;
    }

References _BBS_Backup_Manager().

Referenced by Slic3r::SaveObjectGaurd::SaveObjectGaurd(), Slic3r::SaveObjectGaurd::~SaveObjectGaurd(), Slic3r::backup_soon(), Slic3r::clear_other_changes(), Slic3r::has_other_changes(), Slic3r::put_other_changes(), Slic3r::remove_backup(), Slic3r::run_backup_ui_tasks(), Slic3r::save_object_mesh(), Slic3r::set_backup_callback(), and Slic3r::set_backup_interval().

Here is the call graph for this function:

Here is the caller graph for this function:

has_other_changes()

bool Slic3r::_BBS_Backup_Manager::has_other_changes ( bool backup )

inline

    {
        return backup ? m_other_changes_backup : m_other_changes;
    }

References m_other_changes, and m_other_changes_backup.

operator()()

void Slic3r::_BBS_Backup_Manager::operator() ( )

inline

                      {
        boost::unique_lock lock(m_mutex);
        while (true)
        {
            while (m_tasks.empty()) {
                if (m_interval > 0)
                    m_cond.timed_wait(lock, m_next_backup);
                else
                    m_cond.wait(lock);
                if (m_interval > 0 && boost::get_system_time() > m_next_backup) {
                    m_tasks.push_back({ Backup, 0, std::string(), nullptr, { ++m_task_seq } });
                    m_next_backup += boost::posix_time::seconds(m_interval);
                    // Maybe wakeup from power sleep
                    if (m_next_backup < boost::get_system_time())
                        m_next_backup = boost::get_system_time() + boost::posix_time::seconds(m_interval);
                }
            }
            Task t = m_tasks.front();
            if (t.type == Exit) break;
            if (t.object && t.delay) {
                if (!delay_task(t, lock))
                    continue;
            }
            m_tasks.pop_front();
            auto callback = m_post_callback;
            lock.unlock();
            process_task(t);
            lock.lock();
            if (t.type > None) {
                m_ui_tasks.push_back(t);
                if (m_ui_tasks.size() == 1 && callback)
                    callback(0);
            }
        }
    }

References Backup, delay_task(), Exit, m_cond, m_interval, m_mutex, m_next_backup, m_post_callback, m_task_seq, m_tasks, m_ui_tasks, None, Slic3r::_BBS_Backup_Manager::Task::object, process_task(), and Slic3r::_BBS_Backup_Manager::Task::type.

Here is the call graph for this function:

pop_object_gaurd()

void Slic3r::_BBS_Backup_Manager::pop_object_gaurd ( )

inline

                            {
        auto object = m_gaurd_objects.back();
        m_gaurd_objects.pop_back();
        if (object.second)
            add_object_mesh(*object.first);
    }

References add_object_mesh(), and m_gaurd_objects.

Here is the call graph for this function:

process_task()

void Slic3r::_BBS_Backup_Manager::process_task ( Task & t )

inlineprivate

                               {
        BOOST_LOG_TRIVIAL(info) << "process_task" << t.to_string() << " and interval = " << m_interval;
        switch (t.type) {
            case Backup:
                // do it in response
                break;
            case AddObject: {
                {
                    CNumericLocalesSetter locales_setter;
                    _BBS_3MF_Exporter     e;
                    e.save_object_mesh(t.path, *t.object, (int) t.id);
                    // response to delete cloned object
                }
                break;
            }
            case RemoveObject: {
                boost::system::error_code ec;
                boost::filesystem::remove(t.path + "/mesh_" + boost::lexical_cast<std::string>(t.id) + ".xml", ec);
                t.type = None;
                break;
            }
            case RemoveBackup: {
                try {
                    boost::system::error_code ec;
                    boost::filesystem::remove(t.path + "/.3mf", ec);
                    // We Saved with SplitModel now, so we can safe delete these sub models.
                    boost::filesystem::remove_all(t.path + "/3D/Objects");
                    boost::filesystem::create_directory(t.path + "/3D/Objects");
                }
                catch (...) {}
            }
        }
    }

References AddObject, Backup, Slic3r::_BBS_Backup_Manager::Task::id, m_interval, None, Slic3r::_BBS_Backup_Manager::Task::object, Slic3r::_BBS_Backup_Manager::Task::path, RemoveBackup, RemoveObject, Slic3r::_BBS_3MF_Exporter::save_object_mesh(), Slic3r::_BBS_Backup_Manager::Task::to_string(), and Slic3r::_BBS_Backup_Manager::Task::type.

Referenced by operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

process_ui_task()

void Slic3r::_BBS_Backup_Manager::process_ui_task ( Task & t, bool canceled = false )

inlineprivate

                                                         {
        BOOST_LOG_TRIVIAL(info) << "process_ui_task" << t.to_string() << " and interval = " << m_interval;
        switch (t.type) {
            case Backup: {
                if (canceled)
                    break;
                std::function<void(int)> callback;
                boost::unique_lock lock(m_mutex);
                if (m_task_seq != t.sequence) {
                    if (find(m_tasks.begin(), m_tasks.end(), Task{ Backup }) == m_tasks.end()) {
                        t.sequence = ++m_task_seq; // may has pending tasks, retry later
                        m_tasks.push_back(t);
                        m_cond.notify_all();
                    }
                    break;
                }
                callback = m_post_callback;
                lock.unlock();
                {
                    timer t("backup cost");
                    try {
                        if (callback) callback(1);
                    } catch (...) {}
                }
                m_other_changes_backup = false;
                break;
            }
            case AddObject:
                m_temp_model.delete_object(t.object);
                break;
            case RemoveBackup:
                if (t.removeAll) {
                    try {
                        boost::filesystem::remove(t.path + "/lock.txt");
                        boost::filesystem::remove_all(t.path);
                        BOOST_LOG_TRIVIAL(info) << "process_ui_task: remove all of backup path " << t.path;
                    } catch (std::exception &ex) {
                        BOOST_LOG_TRIVIAL(error) << "process_ui_task: failed to remove backup path" << t.path << ": " << ex.what();
                    }
                }
                break;
        }
    }

References AddObject, Backup, m_cond, m_interval, m_mutex, m_other_changes_backup, m_post_callback, m_task_seq, m_tasks, m_temp_model, Slic3r::_BBS_Backup_Manager::Task::object, Slic3r::_BBS_Backup_Manager::Task::path, RemoveBackup, Slic3r::_BBS_Backup_Manager::Task::to_string(), and Slic3r::_BBS_Backup_Manager::Task::type.

Referenced by push_task(), remove_backup(), and run_ui_tasks().

Here is the call graph for this function:

Here is the caller graph for this function:

push_object_gaurd()

void Slic3r::_BBS_Backup_Manager::push_object_gaurd ( ModelObject & object )

inline

                                                {
        m_gaurd_objects.push_back(std::make_pair(&object, 0));
    }

References m_gaurd_objects.

push_task()

void Slic3r::_BBS_Backup_Manager::push_task ( Task const & t )

inlineprivate

                                   {
        boost::unique_lock lock(m_mutex);
        if (t.delay && !m_tasks.empty() && m_tasks.back() == t) {
            auto t2 = m_tasks.back();
            m_tasks.back() = t;
            m_tasks.back().delay = t2.delay + 1;
            m_cond.notify_all();
            lock.unlock();
            process_ui_task(t2);
        }
        else {
            m_tasks.push_back(t);
            ++m_task_seq;
            m_cond.notify_all();
        }
    }

References m_cond, m_mutex, m_task_seq, m_tasks, and process_ui_task().

Referenced by ~_BBS_Backup_Manager(), add_object_mesh(), and remove_object_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

put_other_changes()

void Slic3r::_BBS_Backup_Manager::put_other_changes ( )

inline

    {
        BOOST_LOG_TRIVIAL(info) << "put_other_changes";
        m_other_changes        = true;
        m_other_changes_backup = true;
    }

References m_other_changes, and m_other_changes_backup.

remove_backup()

void Slic3r::_BBS_Backup_Manager::remove_backup ( Model & model, bool removeAll )

inline

                                                     {
        BOOST_LOG_TRIVIAL(info)
            << "remove_backup " << model.get_backup_path() << ", " << removeAll;
        std::deque<Task>   canceled_tasks;
        boost::unique_lock lock(m_mutex);
        if (removeAll && model.is_need_backup()) {
            // running task may not be canceled
            for (auto & t : m_ui_tasks)
                canceled_tasks.push_back(t);
            for (auto & t : m_tasks)
                canceled_tasks.push_back(t);
            m_ui_tasks.clear();
            m_tasks.clear();
        }
        m_tasks.push_back({ RemoveBackup, model.id().id, model.get_backup_path(), nullptr, { removeAll } });
        ++m_task_seq;
        if (model.is_need_backup()) {
            m_other_changes = false;
            m_other_changes_backup = false;
        }
        m_cond.notify_all();
        lock.unlock();
        for (auto& t : canceled_tasks) {
            process_ui_task(t, true);
        }
    }

References Slic3r::Model::get_backup_path(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::Model::is_need_backup(), m_cond, m_mutex, m_other_changes, m_other_changes_backup, m_task_seq, m_tasks, m_ui_tasks, process_ui_task(), and RemoveBackup.

Here is the call graph for this function:

remove_object_mesh()

void Slic3r::_BBS_Backup_Manager::remove_object_mesh ( ModelObject & object )

inline

                                                 {
        push_task({ RemoveObject, object.id().id, object.get_model()->get_backup_path() });
    }

References push_task(), and RemoveObject.

Here is the call graph for this function:

run_ui_tasks()

void Slic3r::_BBS_Backup_Manager::run_ui_tasks ( )

inline

                        {
        std::deque<Task> tasks;
        {
            boost::lock_guard lock(m_mutex);
            std::swap(tasks, m_ui_tasks);
        }
        for (auto& t : tasks)
        {
            process_ui_task(t);
        }
    }

References m_mutex, m_ui_tasks, and process_ui_task().

Here is the call graph for this function:

set_interval()

void Slic3r::_BBS_Backup_Manager::set_interval ( long n )

inline

                              {
        boost::lock_guard lock(m_mutex);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " entry, and last interval is: " << m_interval;
        m_next_backup -= boost::posix_time::seconds(m_interval);
        m_interval = n;
        m_next_backup += boost::posix_time::seconds(m_interval);
        m_cond.notify_all();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " exit, and new interval is: " << m_interval;
    }

References m_cond, m_interval, m_mutex, and m_next_backup.

set_post_callback()

void Slic3r::_BBS_Backup_Manager::set_post_callback ( std::function< void(int)> c )

inline

                                                     {
        boost::lock_guard lock(m_mutex);
        m_post_callback = c;
    }

References m_mutex, and m_post_callback.

Member Data Documentation

m_cond

boost::condition_variable Slic3r::_BBS_Backup_Manager::m_cond

private

Referenced by backup_soon(), delay_task(), operator()(), process_ui_task(), push_task(), remove_backup(), and set_interval().

m_gaurd_objects

std::vector<std::pair<ModelObject*, size_t> > Slic3r::_BBS_Backup_Manager::m_gaurd_objects

private

Referenced by add_object_mesh(), pop_object_gaurd(), and push_object_gaurd().

m_interval

long Slic3r::_BBS_Backup_Manager::m_interval = 1 * 60

private

Referenced by _BBS_Backup_Manager(), operator()(), process_task(), process_ui_task(), and set_interval().

m_mutex

boost::mutex Slic3r::_BBS_Backup_Manager::m_mutex

private

Referenced by _BBS_Backup_Manager(), backup_soon(), operator()(), process_ui_task(), push_task(), remove_backup(), run_ui_tasks(), set_interval(), and set_post_callback().

m_next_backup

boost::system_time Slic3r::_BBS_Backup_Manager::m_next_backup

private

Referenced by _BBS_Backup_Manager(), operator()(), and set_interval().

m_other_changes

bool Slic3r::_BBS_Backup_Manager::m_other_changes = false

private

Referenced by clear_other_changes(), has_other_changes(), put_other_changes(), and remove_backup().

m_other_changes_backup

bool Slic3r::_BBS_Backup_Manager::m_other_changes_backup = false

private

Referenced by backup_soon(), clear_other_changes(), has_other_changes(), process_ui_task(), put_other_changes(), and remove_backup().

m_post_callback

std::function<void(int)> Slic3r::_BBS_Backup_Manager::m_post_callback

private

Referenced by operator()(), process_ui_task(), and set_post_callback().

m_task_seq

size_t Slic3r::_BBS_Backup_Manager::m_task_seq = 0

private

Referenced by backup_soon(), operator()(), process_ui_task(), push_task(), and remove_backup().

m_tasks

std::deque<Task> Slic3r::_BBS_Backup_Manager::m_tasks

private

Referenced by backup_soon(), delay_task(), operator()(), process_ui_task(), push_task(), and remove_backup().

m_temp_model

Model Slic3r::_BBS_Backup_Manager::m_temp_model

private

Referenced by add_object_mesh(), and process_ui_task().

m_thread

boost::thread Slic3r::_BBS_Backup_Manager::m_thread

private

Referenced by _BBS_Backup_Manager(), and ~_BBS_Backup_Manager().

m_ui_tasks

std::deque<Task> Slic3r::_BBS_Backup_Manager::m_ui_tasks

private

Referenced by operator()(), remove_backup(), and run_ui_tasks().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/bbs_3mf.cpp