Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs > Class Template Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/ThreadSafeQueue.hpp>

Inheritance diagram for Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >:

Collaboration diagram for Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >:

Public Member Functions
template<class Fn>
bool	consume_one (const BlockingWait &blkw, Fn &&fn)
template<class Fn>
bool	consume_one (Fn &&fn)
template<class... TArgs>
void	push (TArgs &&...el)
bool	empty () const
size_t	size () const
void	clear ()

Private Attributes
std::queue< T, Container< T, ContainerArgs... > >	m_queue
std::mutex	m_mutex
std::condition_variable	m_cond_var

Detailed Description

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>
class Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >

Member Function Documentation

clear()

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

void Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::clear ( )

inline

    {
        std::lock_guard lk{m_mutex};
        while (!m_queue.empty())
            m_queue.pop();
    }

consume_one() [1/2]

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

template<class Fn>

bool Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::consume_one ( const BlockingWait & blkw, Fn && fn )

inline

    {
        static_assert(!std::is_reference_v<T>, "");
        static_assert(std::is_default_constructible_v<T>, "");
        static_assert(std::is_move_assignable_v<T> || std::is_copy_assignable_v<T>, "");
 
        T el;
        {
            std::unique_lock lk{m_mutex};
 
            auto pred = [this]{ return !m_queue.empty(); };
            if (blkw.timeout_ms > 0) {
                auto timeout = std::chrono::milliseconds(blkw.timeout_ms);
                if (!m_cond_var.wait_for(lk, timeout, pred))
                    return false;
            }
            else
                m_cond_var.wait(lk, pred);
 
            if constexpr (std::is_move_assignable_v<T>)
                el = std::move(m_queue.front());
            else
                el = m_queue.front();
 
            m_queue.pop();
 
            if (blkw.pop_flag)
                // The optional flag is set before the lock us unlocked.
                blkw.pop_flag->store(true);
        }
 
        fn(el);
        return true;
    }

consume_one() [2/2]

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

template<class Fn>

bool Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::consume_one ( Fn && fn )

inline

    {
        T el;
        {
            std::unique_lock lk{m_mutex};
            if (!m_queue.empty()) {
                if constexpr (std::is_move_assignable_v<T>)
                    el = std::move(m_queue.front());
                else
                    el = m_queue.front();
 
                m_queue.pop();
            } else
                return false;
        }
 
        fn(el);
 
        return true;
    }

empty()

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

bool Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::empty ( ) const

inline

    {
        std::lock_guard lk{m_mutex};
        return m_queue.empty();
    }

push()

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

template<class... TArgs>

void Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::push ( TArgs &&... el )

inline

    {
        std::lock_guard lk{m_mutex};
        m_queue.emplace(std::forward<TArgs>(el)...);
        m_cond_var.notify_one();
    }

size()

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

size_t Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::size ( ) const

inline

    {
        std::lock_guard lk{m_mutex};
        return m_queue.size();
    }

Member Data Documentation

m_cond_var

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

std::condition_variable Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::m_cond_var

private

m_mutex

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

std::mutex Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::m_mutex

mutableprivate

m_queue

template<class T, template< class, class... > class Container = std::deque, class... ContainerArgs>

std::queue<T, Container<T, ContainerArgs...> > Slic3r::GUI::ThreadSafeQueueSPSC< T, Container, ContainerArgs >::m_queue

private

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/ThreadSafeQueue.hpp