Slic3r::PrintState< StepType, COUNT > Class Template Reference

#include <src/libslic3r/PrintBase.hpp>

Inheritance diagram for Slic3r::PrintState< StepType, COUNT >:

Collaboration diagram for Slic3r::PrintState< StepType, COUNT >:

Public Types
enum class	State {   Fresh , Started , Canceled , Done ,   Invalidated }
enum class	WarningLevel { NON_CRITICAL , CRITICAL }
typedef size_t	TimeStamp

Public Member Functions
	PrintState ()
StateWithTimeStamp	state_with_timestamp (StepType step, std::mutex &mtx) const
StateWithWarnings	state_with_warnings (StepType step, std::mutex &mtx) const
bool	is_started (StepType step, std::mutex &mtx) const
bool	is_done (StepType step, std::mutex &mtx) const
StateWithTimeStamp	state_with_timestamp_unguarded (StepType step) const
bool	is_started_unguarded (StepType step) const
bool	is_done_unguarded (StepType step) const
void	enable_unguarded (StepType step, bool enable)
void	enable_all_unguarded (bool enable)
bool	is_enabled_unguarded (StepType step) const
template<typename ThrowIfCanceled >
bool	set_started (StepType step, std::mutex &mtx, ThrowIfCanceled throw_if_canceled)
template<typename ThrowIfCanceled >
std::pair< TimeStamp, bool >	set_done (StepType step, std::mutex &mtx, ThrowIfCanceled throw_if_canceled)
template<typename CancelationCallback >
bool	invalidate (StepType step, CancelationCallback cancel)
template<typename CancelationCallback , typename StepTypeIterator >
bool	invalidate_multiple (StepTypeIterator step_begin, StepTypeIterator step_end, CancelationCallback cancel)
template<typename CancelationCallback >
bool	invalidate_all (CancelationCallback cancel)
bool	query_reset_dirty_unguarded (StepType step)
void	mark_canceled_unguarded ()
std::pair< StepType, bool >	active_step_add_warning (PrintStateBase::WarningLevel warning_level, const std::string &message, int message_id, std::mutex &mtx)

Static Protected Attributes
static size_t	g_last_timestamp = 0

Private Attributes
StateWithWarnings	m_state [COUNT]
int	m_step_active = -1

Detailed Description

template<class StepType, size_t COUNT>
class Slic3r::PrintState< StepType, COUNT >

Member Typedef Documentation

TimeStamp

typedef size_t Slic3r::PrintStateBase::TimeStamp

inherited

Member Enumeration Documentation

State

enum class Slic3r::PrintStateBase::State

stronginherited

Enumerator
Fresh
Started
Canceled
Done
Invalidated

                     {
        // Fresh state, either the object is new or the data of that particular milestone was cleaned up.
        // Fresh state may transit to Started.
        Fresh,
        // Milestone was started and now it is being executed.
        // Started state may transit to Canceled with invalid data or Done with valid data.
        Started,
        // Milestone was being executed, but now it is canceled and not yet cleaned up.
        // Canceled state may transit to Fresh state if its invalid data is cleaned up
        // or to Started state.
        // Canceled and Invalidated states are of similar nature: Canceled step was Started but canceled,
        // while Invalidated state was Done but invalidated.
        Canceled,
        // Milestone was finished successfully, it's data is now valid.
        // Done state may transit to Invalidated state if its data is no more valid
        // or to a Started state.
        Done,
        // Milestone was finished successfully (done), but now it is invalidated and it's data is no more valid.
        // Invalidated state may transit to Fresh if its invalid data is cleaned up,
        // or to state Started.
        // Canceled and Invalidated states are of similar nature: Canceled step was Started but canceled,
        // while Invalidated state was Done but invalidated.
        Invalidated,
    };

WarningLevel

enum class Slic3r::PrintStateBase::WarningLevel

stronginherited

Enumerator
NON_CRITICAL
CRITICAL

                            {
        NON_CRITICAL,
        CRITICAL
    };

Constructor & Destructor Documentation

PrintState()

template<class StepType , size_t COUNT>

Slic3r::PrintState< StepType, COUNT >::PrintState ( )

inline

{}

Member Function Documentation

active_step_add_warning()

template<class StepType , size_t COUNT>

std::pair< StepType, bool > Slic3r::PrintState< StepType, COUNT >::active_step_add_warning ( PrintStateBase::WarningLevel  warning_level, const std::string &  message, int  message_id, std::mutex &  mtx  )

inline

    {
        std::scoped_lock<std::mutex> lock(mtx);
        assert(m_step_active != -1);
        StateWithWarnings &state = m_state[m_step_active];
        assert(state.state == State::Started);
        std::pair<StepType, bool> retval(static_cast<StepType>(m_step_active), true);
        // Does a warning of the same level and message or message_id exist already?
    auto it = (message_id == 0) ? 
            std::find_if(state.warnings.begin(), state.warnings.end(), [&message](const auto &w) { return w.message_id == 0 && w.message == message; }) :
            std::find_if(state.warnings.begin(), state.warnings.end(), [message_id](const auto& w) { return w.message_id == message_id; });
      if (it == state.warnings.end())
        // No, create a new warning and update UI.
          state.warnings.emplace_back(PrintStateBase::Warning{ warning_level, true, message, message_id });
        else if (it->message != message || it->level != warning_level) {
          // Yes, however it needs an update.
          it->message = message;
          it->level   = warning_level;
          it->current = true;
        } else if (it->current)
          // Yes, and it is current. Don't update UI.
          retval.second = false;
        else
          // Yes, but it is not current. Mark it as current.
          it->current = true;
        return retval;
    }

References Slic3r::PrintState< StepType, COUNT >::m_state, Slic3r::PrintState< StepType, COUNT >::m_step_active, Slic3r::PrintStateBase::Started, Slic3r::PrintStateBase::StateWithTimeStamp::state, and Slic3r::PrintStateBase::StateWithWarnings::warnings.

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::active_step_add_warning(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::active_step_add_warning().

Here is the caller graph for this function:

enable_all_unguarded()

template<class StepType , size_t COUNT>

void Slic3r::PrintState< StepType, COUNT >::enable_all_unguarded ( bool  enable )

inline

                                           {
        for (size_t istep = 0; istep < COUNT; ++ istep)
            m_state[istep].enabled = enable;
    }

References Slic3r::PrintState< StepType, COUNT >::m_state.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::enable_all_steps_unguarded(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::finalize_impl(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::finalize_impl().

Here is the caller graph for this function:

enable_unguarded()

template<class StepType , size_t COUNT>

void Slic3r::PrintState< StepType, COUNT >::enable_unguarded ( StepType  step, bool  enable  )

inline

                                                      {
        m_state[step].enabled = enable;
    }

References Slic3r::PrintStateBase::StateWithTimeStamp::enabled, and Slic3r::PrintState< StepType, COUNT >::m_state.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::enable_step_unguarded(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_task_impl().

Here is the caller graph for this function:

invalidate()

template<class StepType , size_t COUNT>

template<typename CancelationCallback >

bool Slic3r::PrintState< StepType, COUNT >::invalidate ( StepType  step, CancelationCallback  cancel  )

inline

                                                               {
        if (PrintStateBase::StateWithWarnings &state = m_state[step]; state.try_invalidate()) {
#if 0
            if (mtx.state != mtx.HELD) {
                printf("Not held!\n");
            }
#endif
            // Raise the mutex, so that the following cancel() callback could cancel
            // the background processing.
            // Internally the cancel() callback shall unlock the PrintBase::m_status_mutex to let
            // the working thread proceed.
            cancel();
            // Now the worker thread should be stopped, therefore it cannot write into the warnings field.
            // It is safe to modify it.
            state.mark_warnings_non_current();
            m_step_active = -1;
            return true;
        } else
            return false;
    }

References Slic3r::PrintState< StepType, COUNT >::m_state, Slic3r::PrintState< StepType, COUNT >::m_step_active, and Slic3r::PrintStateBase::StateWithTimeStamp::try_invalidate().

Referenced by Slic3r::BackgroundSlicingProcess::invalidate_step(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_step(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_step().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_all()

template<class StepType , size_t COUNT>

template<typename CancelationCallback >

bool Slic3r::PrintState< StepType, COUNT >::invalidate_all ( CancelationCallback  cancel )

inline

                                                    {
        bool invalidated = false;
        for (size_t i = 0; i < COUNT; ++ i)
            if (m_state[i].try_invalidate())
                invalidated = true;
        if (invalidated) {
            cancel();
            // Now the worker thread should be stopped, therefore it cannot write into the warnings field.
            // It is safe to modify the warnings.
            for (size_t i = 0; i < COUNT; ++ i)
                m_state[i].mark_warnings_non_current();
            m_step_active = -1;
        }
        return invalidated;
    }

References Slic3r::PrintState< StepType, COUNT >::m_state, and Slic3r::PrintState< StepType, COUNT >::m_step_active.

Referenced by Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_all_steps(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_all_steps(), and Slic3r::BackgroundSlicingProcess::invalidate_all_steps().

Here is the caller graph for this function:

invalidate_multiple()

template<class StepType , size_t COUNT>

template<typename CancelationCallback , typename StepTypeIterator >

bool Slic3r::PrintState< StepType, COUNT >::invalidate_multiple ( StepTypeIterator  step_begin, StepTypeIterator  step_end, CancelationCallback  cancel  )

inline

                                                                                                                 {
        bool invalidated = false;
        for (StepTypeIterator it = step_begin; it != step_end; ++ it)
            if (m_state[*it].try_invalidate())
                invalidated = true;
        if (invalidated) {
#if 0
            if (mtx.state != mtx.HELD) {
                printf("Not held!\n");
            }
#endif
            // Raise the mutex, so that the following cancel() callback could cancel
            // the background processing.
            // Internally the cancel() callback shall unlock the PrintBase::m_status_mutex to let
            // the working thread to proceed.
            cancel();
            // Now the worker thread should be stopped, therefore it cannot write into the warnings field.
            // It is safe to modify the warnings.
            for (StepTypeIterator it = step_begin; it != step_end; ++ it)
                m_state[*it].mark_warnings_non_current();
            m_step_active = -1;
        }
        return invalidated;
    }

References Slic3r::PrintState< StepType, COUNT >::m_state, and Slic3r::PrintState< StepType, COUNT >::m_step_active.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_steps(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::invalidate_steps(), and Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::invalidate_steps().

Here is the caller graph for this function:

is_done()

template<class StepType , size_t COUNT>

bool Slic3r::PrintState< StepType, COUNT >::is_done ( StepType  step, std::mutex &  mtx  ) const

inline

                                                     {
        return this->state_with_timestamp(step, mtx).state == State::Done;
    }

References Slic3r::PrintStateBase::Done, Slic3r::PrintStateBase::StateWithTimeStamp::state, and Slic3r::PrintState< StepType, COUNT >::state_with_timestamp().

Referenced by Slic3r::BackgroundSlicingProcess::is_step_done(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_done().

Here is the call graph for this function:

Here is the caller graph for this function:

is_done_unguarded()

template<class StepType , size_t COUNT>

bool Slic3r::PrintState< StepType, COUNT >::is_done_unguarded ( StepType  step ) const

inline

                                                {
        return this->state_with_timestamp_unguarded(step).state == State::Done;
    }

References Slic3r::PrintStateBase::Done, Slic3r::PrintStateBase::StateWithTimeStamp::state, and Slic3r::PrintState< StepType, COUNT >::state_with_timestamp_unguarded().

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_done_unguarded(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_done_unguarded().

Here is the call graph for this function:

Here is the caller graph for this function:

is_enabled_unguarded()

template<class StepType , size_t COUNT>

bool Slic3r::PrintState< StepType, COUNT >::is_enabled_unguarded ( StepType  step ) const

inline

                                                   {
        return this->state_with_timestamp_unguarded(step).enabled;
    }

References Slic3r::PrintStateBase::StateWithTimeStamp::enabled, and Slic3r::PrintState< StepType, COUNT >::state_with_timestamp_unguarded().

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_enabled_unguarded().

Here is the call graph for this function:

Here is the caller graph for this function:

is_started()

template<class StepType , size_t COUNT>

bool Slic3r::PrintState< StepType, COUNT >::is_started ( StepType  step, std::mutex &  mtx  ) const

inline

                                                        {
        return this->state_with_timestamp(step, mtx).state == State::Started;
    }

References Slic3r::PrintStateBase::Started, Slic3r::PrintStateBase::StateWithTimeStamp::state, and Slic3r::PrintState< StepType, COUNT >::state_with_timestamp().

Here is the call graph for this function:

is_started_unguarded()

template<class StepType , size_t COUNT>

bool Slic3r::PrintState< StepType, COUNT >::is_started_unguarded ( StepType  step ) const

inline

                                                   {
        return this->state_with_timestamp_unguarded(step).state == State::Started;
    }

References Slic3r::PrintStateBase::Started, Slic3r::PrintStateBase::StateWithTimeStamp::state, and Slic3r::PrintState< StepType, COUNT >::state_with_timestamp_unguarded().

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::is_step_started_unguarded(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::is_step_started_unguarded().

Here is the call graph for this function:

Here is the caller graph for this function:

mark_canceled_unguarded()

template<class StepType , size_t COUNT>

void Slic3r::PrintState< StepType, COUNT >::mark_canceled_unguarded ( )

inline

                                   {
        for (size_t i = 0; i < COUNT; ++ i) {
            if (State &state = m_state[i].state; state == State::Started)
                state = State::Canceled;
        }
    }

References Slic3r::PrintStateBase::Canceled, Slic3r::PrintState< StepType, COUNT >::m_state, and Slic3r::PrintStateBase::Started.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::finalize_impl(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::finalize_impl().

Here is the caller graph for this function:

query_reset_dirty_unguarded()

template<class StepType , size_t COUNT>

bool Slic3r::PrintState< StepType, COUNT >::query_reset_dirty_unguarded ( StepType  step )

inline

                                                    {
        if (PrintStateBase::StateWithWarnings &state = m_state[step]; state.is_dirty()) {
            state.state = State::Fresh;
            return true;
        } else
            return false;
    }

References Slic3r::PrintStateBase::Fresh, Slic3r::PrintStateBase::StateWithTimeStamp::is_dirty(), and Slic3r::PrintState< StepType, COUNT >::m_state.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::query_reset_dirty_step_unguarded().

Here is the call graph for this function:

Here is the caller graph for this function:

set_done()

template<class StepType , size_t COUNT>

template<typename ThrowIfCanceled >

std::pair< TimeStamp, bool > Slic3r::PrintState< StepType, COUNT >::set_done ( StepType  step, std::mutex &  mtx, ThrowIfCanceled  throw_if_canceled  )

inline

                                                                                                     {
        std::scoped_lock<std::mutex> lock(mtx);
        // If canceled, throw before changing the step state.
        throw_if_canceled();
        assert(m_state[step].state == State::Started);
        assert(m_step_active == static_cast<int>(step));
        PrintStateBase::StateWithWarnings &state = m_state[step];
        state.state = State::Done;
        state.timestamp = ++ g_last_timestamp;
        m_step_active = -1;
        // Remove all non-current warnings.
      auto it = std::remove_if(state.warnings.begin(), state.warnings.end(), [](const auto &w) { return ! w.current; });
      bool update_warning_ui = false;
        if (it != state.warnings.end()) {
          state.warnings.erase(it, state.warnings.end());
          update_warning_ui = true;
        }
        return std::make_pair(state.timestamp, update_warning_ui);
    }

References Slic3r::PrintStateBase::Done, Slic3r::PrintStateBase::g_last_timestamp, Slic3r::PrintState< StepType, COUNT >::m_state, Slic3r::PrintState< StepType, COUNT >::m_step_active, Slic3r::PrintStateBase::Started, Slic3r::PrintStateBase::StateWithTimeStamp::state, Slic3r::PrintStateBase::StateWithTimeStamp::timestamp, and Slic3r::PrintStateBase::StateWithWarnings::warnings.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_done(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done(), and Slic3r::BackgroundSlicingProcess::set_step_done().

Here is the caller graph for this function:

set_started()

template<class StepType , size_t COUNT>

template<typename ThrowIfCanceled >

bool Slic3r::PrintState< StepType, COUNT >::set_started ( StepType  step, std::mutex &  mtx, ThrowIfCanceled  throw_if_canceled  )

inline

                                                                                      {
        std::scoped_lock<std::mutex> lock(mtx);
        // If canceled, throw before changing the step state.
        throw_if_canceled();
#ifndef NDEBUG
// The following test is not necessarily valid after the background processing thread
// is stopped with throw_if_canceled(), as the CanceledException is not being catched
// by the Print or PrintObject to update m_step_active or m_state[...].state.
// This should not be a problem as long as the caller calls set_started() / set_done() /
// active_step_add_warning() consistently. From the robustness point of view it would be
// be better to catch CanceledException and do the updates. From the performance point of view,
// the current implementation is optimal.
//
//        assert(m_step_active == -1);
//        for (int i = 0; i < int(COUNT); ++ i)
//            assert(m_state[i].state != State::Started);
#endif // NDEBUG
        PrintStateBase::StateWithWarnings &state = m_state[step];
        if (! state.enabled || state.state == State::Done)
            return false;
        state.state = State::Started;
        state.timestamp = ++ g_last_timestamp;
        state.mark_warnings_non_current();
        m_step_active = static_cast<int>(step);
        return true;
    }

References Slic3r::PrintStateBase::Done, Slic3r::PrintStateBase::StateWithTimeStamp::enabled, Slic3r::PrintStateBase::g_last_timestamp, Slic3r::PrintState< StepType, COUNT >::m_state, Slic3r::PrintState< StepType, COUNT >::m_step_active, Slic3r::PrintStateBase::StateWithWarnings::mark_warnings_non_current(), Slic3r::PrintStateBase::Started, Slic3r::PrintStateBase::StateWithTimeStamp::state, and Slic3r::PrintStateBase::StateWithTimeStamp::timestamp.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::set_started(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_started(), and Slic3r::BackgroundSlicingProcess::set_step_started().

Here is the call graph for this function:

Here is the caller graph for this function:

state_with_timestamp()

template<class StepType , size_t COUNT>

StateWithTimeStamp Slic3r::PrintState< StepType, COUNT >::state_with_timestamp ( StepType  step, std::mutex &  mtx  ) const

inline

                                                                                {
        std::scoped_lock<std::mutex> lock(mtx);
        StateWithTimeStamp state = m_state[step];
        return state;
    }

References Slic3r::PrintState< StepType, COUNT >::m_state.

Referenced by Slic3r::PrintState< StepType, COUNT >::is_done(), Slic3r::PrintState< StepType, COUNT >::is_started(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_timestamp(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_timestamp().

Here is the caller graph for this function:

state_with_timestamp_unguarded()

template<class StepType , size_t COUNT>

StateWithTimeStamp Slic3r::PrintState< StepType, COUNT >::state_with_timestamp_unguarded ( StepType  step ) const

inline

                                                                           { 
        return m_state[step];
    }

References Slic3r::PrintState< StepType, COUNT >::m_state.

Referenced by Slic3r::PrintState< StepType, COUNT >::is_done_unguarded(), Slic3r::PrintState< StepType, COUNT >::is_enabled_unguarded(), and Slic3r::PrintState< StepType, COUNT >::is_started_unguarded().

Here is the caller graph for this function:

state_with_warnings()

template<class StepType , size_t COUNT>

StateWithWarnings Slic3r::PrintState< StepType, COUNT >::state_with_warnings ( StepType  step, std::mutex &  mtx  ) const

inline

                                                                              {
        std::scoped_lock<std::mutex> lock(mtx);
        StateWithWarnings state = m_state[step];
        return state;
    }

References Slic3r::PrintState< StepType, COUNT >::m_state.

Referenced by Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::step_state_with_warnings(), and Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_warnings().

Here is the caller graph for this function:

Member Data Documentation

g_last_timestamp

size_t Slic3r::PrintStateBase::g_last_timestamp = 0

staticprotectedinherited

Referenced by Slic3r::PrintState< StepType, COUNT >::set_done(), Slic3r::PrintState< StepType, COUNT >::set_started(), and Slic3r::PrintStateBase::StateWithTimeStamp::try_invalidate().

m_state

template<class StepType , size_t COUNT>

StateWithWarnings Slic3r::PrintState< StepType, COUNT >::m_state[COUNT]

private

Referenced by Slic3r::PrintState< StepType, COUNT >::active_step_add_warning(), Slic3r::PrintState< StepType, COUNT >::enable_all_unguarded(), Slic3r::PrintState< StepType, COUNT >::enable_unguarded(), Slic3r::PrintState< StepType, COUNT >::invalidate(), Slic3r::PrintState< StepType, COUNT >::invalidate_all(), Slic3r::PrintState< StepType, COUNT >::invalidate_multiple(), Slic3r::PrintState< StepType, COUNT >::mark_canceled_unguarded(), Slic3r::PrintState< StepType, COUNT >::query_reset_dirty_unguarded(), Slic3r::PrintState< StepType, COUNT >::set_done(), Slic3r::PrintState< StepType, COUNT >::set_started(), Slic3r::PrintState< StepType, COUNT >::state_with_timestamp(), Slic3r::PrintState< StepType, COUNT >::state_with_timestamp_unguarded(), and Slic3r::PrintState< StepType, COUNT >::state_with_warnings().

m_step_active

template<class StepType , size_t COUNT>

int Slic3r::PrintState< StepType, COUNT >::m_step_active = -1

private

Referenced by Slic3r::PrintState< StepType, COUNT >::active_step_add_warning(), Slic3r::PrintState< StepType, COUNT >::invalidate(), Slic3r::PrintState< StepType, COUNT >::invalidate_all(), Slic3r::PrintState< StepType, COUNT >::invalidate_multiple(), Slic3r::PrintState< StepType, COUNT >::set_done(), and Slic3r::PrintState< StepType, COUNT >::set_started().

---

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

• src/libslic3r/PrintBase.hpp