Slic3r::GUI::Lazy< T > Class Template Reference

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

Inheritance diagram for Slic3r::GUI::Lazy< T >:

Collaboration diagram for Slic3r::GUI::Lazy< T >:

Public Types
using	Factory = std::function<T*()>

Public Member Functions
	Lazy (std::string name, int order, Factory make)
	~Lazy () override
	Lazy (const Lazy &)=delete
Lazy &	operator= (const Lazy &)=delete
T *	get () const
T *	ensure ()
void	when_built (std::function< void(T &)> fn)
const std::string &	name () const override
bool	built () const override
bool	pending () const override
int	prebuild_order () const override
bool	build_step () override

Static Protected Member Functions
static void	log_null_factory (const std::string &name)

Private Member Functions
bool	steps_remain () const
void	step ()

Static Private Member Functions
static constexpr bool	registered ()
static constexpr bool	staged ()

Private Attributes
std::string	m_name
int	m_order
Factory	m_make
T *	m_object { nullptr }
std::atomic< bool >	m_complete { false }
bool	m_building { false }
bool	m_failed { false }
std::vector< std::function< void(T &)> >	m_deferred

Detailed Description

template<class T>
class Slic3r::GUI::Lazy< T >

Member Typedef Documentation

Factory

template<class T>

using Slic3r::GUI::Lazy< T >::Factory = std::function<T*()>

Constructor & Destructor Documentation

Lazy() [1/2]

template<class T>

Slic3r::GUI::Lazy< T >::Lazy ( std::string name, int order, Factory make )

inline

                                                  : m_name(std::move(name)), m_order(order), m_make(std::move(make))
    {
        if constexpr (registered())
            LazyInstance<T>::s_lazy = this;
    }

References m_make, m_name, m_order, name(), registered(), and Slic3r::GUI::LazyInstance< Self >::s_lazy.

Referenced by Lazy(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

~Lazy()

template<class T>

Slic3r::GUI::Lazy< T >::~Lazy ( )

inlineoverride

    {
        if constexpr (registered())
            if (LazyInstance<T>::s_lazy == this)
                LazyInstance<T>::s_lazy = nullptr;
    }

References registered(), and Slic3r::GUI::LazyInstance< Self >::s_lazy.

Here is the call graph for this function:

Lazy() [2/2]

template<class T>

Slic3r::GUI::Lazy< T >::Lazy ( const Lazy< T > & )

delete

References Lazy().

Here is the call graph for this function:

Member Function Documentation

build_step()

template<class T>

bool Slic3r::GUI::Lazy< T >::build_step ( )

inlineoverridevirtual

Implements Slic3r::GUI::LazyBase.

    {
        if (built() || m_building || m_failed)
            return false;
        m_building = true;
        try {
            if (m_object == nullptr)
                m_object = m_make();
            else
                step();
        } catch (...) {
            m_building = false;
            throw;
        }
        m_building = false;
        if (m_object == nullptr) {
            m_failed = true;
            log_null_factory(m_name);
            return false;
        }
        if (steps_remain())
            return true;
        m_complete.store(true, std::memory_order_release);
        for (auto& fn : m_deferred)
            fn(*m_object);
        m_deferred.clear();
        return false;
    }

References built(), Slic3r::GUI::LazyBase::log_null_factory(), m_building, m_complete, m_deferred, m_failed, m_make, m_name, m_object, step(), and steps_remain().

Referenced by ensure().

Here is the call graph for this function:

Here is the caller graph for this function:

built()

template<class T>

bool Slic3r::GUI::Lazy< T >::built ( ) const

inlineoverridevirtual

Implements Slic3r::GUI::LazyBase.

{ return m_complete.load(std::memory_order_acquire); }

References m_complete.

Referenced by build_step(), ensure(), get(), pending(), and when_built().

Here is the caller graph for this function:

ensure()

template<class T>

T * Slic3r::GUI::Lazy< T >::ensure ( )

inline

    {
        if (!built() && !m_building) {
            OnDemandBuild build(*this);
            do
                build.unit();
            while (build_step());
        }
        return get();
    }

References build_step(), built(), get(), m_building, and Slic3r::GUI::LazyBase::OnDemandBuild::unit().

Here is the call graph for this function:

get()

template<class T>

T * Slic3r::GUI::Lazy< T >::get ( ) const

inline

{ return built() ? m_object : nullptr; }

References built(), and m_object.

Referenced by ensure(), and Slic3r::PluginPages::remove_page().

Here is the call graph for this function:

Here is the caller graph for this function:

log_null_factory()

void Slic3r::GUI::LazyBase::log_null_factory ( const std::string & name )

staticprotectedinherited

{
    BOOST_LOG_TRIVIAL(error) << "Lazy::build_step: the factory for " << name << " returned null";
}

References name().

Referenced by Slic3r::GUI::Lazy< T >::build_step().

Here is the call graph for this function:

Here is the caller graph for this function:

name()

template<class T>

const std::string & Slic3r::GUI::Lazy< T >::name ( ) const

inlineoverridevirtual

Implements Slic3r::GUI::LazyBase.

{ return m_name; }

References m_name.

Referenced by Lazy().

Here is the caller graph for this function:

operator=()

template<class T>

Lazy & Slic3r::GUI::Lazy< T >::operator= ( const Lazy< T > & )

delete

References Lazy().

Here is the call graph for this function:

pending()

template<class T>

bool Slic3r::GUI::Lazy< T >::pending ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::GUI::LazyBase.

Reimplemented in Slic3r::GUI::LazyPage< Panel >, Slic3r::GUI::LazyPage< Slic3r::GUI::CalibrationPanel >, Slic3r::GUI::LazyPage< Slic3r::GUI::MonitorPanel >, Slic3r::GUI::LazyPage< Slic3r::GUI::MultiMachinePage >, Slic3r::GUI::LazyPage< Slic3r::GUI::PrinterWebView >, Slic3r::GUI::LazyPage< Slic3r::GUI::ProjectPanel >, Slic3r::GUI::LazyPage< Slic3r::GUI::WebViewPanel >, and Slic3r::GUI::LazyPage< Slic3r::PluginPage >.

{ return !built() && !m_failed; }

References built(), and m_failed.

Referenced by Slic3r::GUI::LazyPage< Panel >::pending().

Here is the call graph for this function:

Here is the caller graph for this function:

prebuild_order()

template<class T>

int Slic3r::GUI::Lazy< T >::prebuild_order ( ) const

inlineoverridevirtual

Implements Slic3r::GUI::LazyBase.

{ return m_order; }

References m_order.

registered()

template<class T>

constexpr bool Slic3r::GUI::Lazy< T >::registered ( )

inlinestaticconstexprprivate

{ return std::is_base_of_v<LazyInstance<T>, T>; }

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

Here is the caller graph for this function:

staged()

template<class T>

constexpr bool Slic3r::GUI::Lazy< T >::staged ( )

inlinestaticconstexprprivate

{ return std::is_base_of_v<StagedBuild, T>; }

Referenced by step(), and steps_remain().

Here is the caller graph for this function:

step()

template<class T>

void Slic3r::GUI::Lazy< T >::step ( )

inlineprivate

    {
        if constexpr (staged())
            m_object->build_step();
    }

References m_object, and staged().

Referenced by build_step().

Here is the call graph for this function:

Here is the caller graph for this function:

steps_remain()

template<class T>

bool Slic3r::GUI::Lazy< T >::steps_remain ( ) const

inlineprivate

    {
        if constexpr (staged())
            return !m_object->built();
        else
            return false;
    }

References m_object, and staged().

Referenced by build_step().

Here is the call graph for this function:

Here is the caller graph for this function:

when_built()

template<class T>

void Slic3r::GUI::Lazy< T >::when_built ( std::function< void(T &)> fn )

inline

    {
        if (built())
            fn(*m_object);
        else
            m_deferred.push_back(std::move(fn));
    }

References built(), m_deferred, and m_object.

Here is the call graph for this function:

Member Data Documentation

m_building

template<class T>

bool Slic3r::GUI::Lazy< T >::m_building { false }

private

{ false };

Referenced by build_step(), and ensure().

m_complete

template<class T>

std::atomic<bool> Slic3r::GUI::Lazy< T >::m_complete { false }

private

{ false };

Referenced by build_step(), and built().

m_deferred

template<class T>

std::vector<std::function<void(T&)> > Slic3r::GUI::Lazy< T >::m_deferred

private

Referenced by build_step(), and when_built().

m_failed

template<class T>

bool Slic3r::GUI::Lazy< T >::m_failed { false }

private

{ false };

Referenced by build_step(), and pending().

m_make

template<class T>

Factory Slic3r::GUI::Lazy< T >::m_make

private

Referenced by Lazy(), and build_step().

m_name

template<class T>

std::string Slic3r::GUI::Lazy< T >::m_name

private

Referenced by Lazy(), build_step(), and name().

m_object

template<class T>

T* Slic3r::GUI::Lazy< T >::m_object { nullptr }

private

{ nullptr };

Referenced by build_step(), get(), step(), steps_remain(), and when_built().

m_order

template<class T>

int Slic3r::GUI::Lazy< T >::m_order

private

Referenced by Lazy(), and prebuild_order().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Lazy.hpp