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

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/PrintBase.hpp>

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

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

Public Types
enum	State { INVALID , STARTED , DONE }
enum class	WarningLevel { NON_CRITICAL , CRITICAL }
enum	SlicingNotificationType {   SlicingDefaultNotification = 0 , SlicingReplaceInitEmptyLayers , SlicingNeedSupportOn , SlicingEmptyGcodeLayers ,   SlicingGcodeOverlap , SlicingExclusionVolumeToolpath , SlicingPreciseSeamWarning }
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
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)
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

SlicingNotificationType

enum Slic3r::PrintStateBase::SlicingNotificationType

inherited

Enumerator
SlicingDefaultNotification
SlicingReplaceInitEmptyLayers
SlicingNeedSupportOn
SlicingEmptyGcodeLayers
SlicingGcodeOverlap
SlicingExclusionVolumeToolpath
SlicingPreciseSeamWarning

    {
        SlicingDefaultNotification = 0,    //normal status update, called by set_status
        SlicingReplaceInitEmptyLayers,
        SlicingNeedSupportOn,
        SlicingEmptyGcodeLayers,
        SlicingGcodeOverlap,
        SlicingExclusionVolumeToolpath,
        SlicingPreciseSeamWarning
    };

State

enum Slic3r::PrintStateBase::State

inherited

Enumerator
INVALID
STARTED
DONE

               {
        INVALID,
        STARTED,
        DONE,
    };

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 == 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;
    }

invalidate()

template<class StepType, size_t COUNT>

template<typename CancelationCallback>

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

inline

                                                               {
        bool invalidated = m_state[step].state != INVALID;
        if (invalidated) {
#if 0
            if (mtx.state != mtx.HELD) {
                printf("Not held!\n");
            }
#endif
            PrintStateBase::StateWithWarnings &state = m_state[step];
            state.state = INVALID;
            state.timestamp = ++ g_last_timestamp;
            // 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 invalidated;
    }

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) {
            StateWithTimeStamp &state = m_state[i];
            if (state.state != INVALID) {
                invalidated = true;
                state.state = INVALID;
                state.timestamp = ++ g_last_timestamp;
            }
        }
        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;
    }

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) {
            StateWithTimeStamp &state = m_state[*it];
            if (state.state != INVALID) {
                invalidated = true;
                state.state = INVALID;
                state.timestamp = ++ g_last_timestamp;
            }
        }
        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;
    }

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 == DONE;
    }

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 == DONE;
    }

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 == STARTED;
    }

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 == STARTED;
    }

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 == STARTED);
        assert(m_step_active == static_cast<int>(step));
        PrintStateBase::StateWithWarnings &state = m_state[step];
        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);
    }

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 != STARTED);
#endif // NDEBUG
        if (m_state[step].state == DONE)
            return false;
        PrintStateBase::StateWithWarnings &state = m_state[step];
        state.state = STARTED;
        state.timestamp = ++ g_last_timestamp;
        state.mark_warnings_non_current();
        m_step_active = static_cast<int>(step);
        return true;
    }

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;
    }

Referenced by Slic3r::PrintState< PrintObjectStepEnum, COUNT >::is_done(), and Slic3r::PrintState< PrintObjectStepEnum, COUNT >::is_started().

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];
    }

Referenced by Slic3r::PrintState< PrintObjectStepEnum, COUNT >::is_done_unguarded(), and Slic3r::PrintState< PrintObjectStepEnum, 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;
    }

Member Data Documentation

g_last_timestamp

size_t Slic3r::PrintStateBase::g_last_timestamp = 0

staticprotectedinherited

m_state

template<class StepType, size_t COUNT>

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

private

m_step_active

template<class StepType, size_t COUNT>

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

private

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/PrintBase.hpp