#include <scheduler.h>

Collaboration diagram for action_s:

[legend]

Public Member Functions
	action_s () noexcept=default

	action_s (action_s const &) noexcept=default

	action_s (action_s &&other) noexcept

action_s &	operator= (action_s const &) noexcept=default

action_s &	operator= (action_s &&other) noexcept

void	execute () const

constexpr schfunc_t	getCallback () const

constexpr scheduler_arg_t const &	getArgumentRaw () const

template<typename T >
constexpr T	getArgument () const

constexpr	operator bool () const

bool constexpr	operator== (const action_s &other) const

constexpr char const *	getCallbackName () const

Static Public Member Functions
template<auto Func, typename Arg >
static constexpr action_s	make (Arg arg) noexcept(std::is_nothrow_constructible_v< action_s, schfunc_t, scheduler_arg_t >)

template<auto Func>
static constexpr action_s	make () noexcept(std::is_nothrow_constructible_v< action_s, schfunc_t >)

Private Types
using	schfunc_t = void(*)(scheduler_arg_t)

Private Member Functions
constexpr	action_s (const schfunc_t callback, char const *const fn_name_) noexcept

constexpr	action_s (const schfunc_t callback, const scheduler_arg_t param, char const *const fn_name_) noexcept

constexpr	action_s (const schfunc_t callback) noexcept

constexpr	action_s (const schfunc_t callback, const scheduler_arg_t param) noexcept

Static Private Member Functions
template<typename T >
static constexpr T	from_scheduler_arg_t (scheduler_arg_t raw) noexcept

template<typename T >
static constexpr scheduler_arg_t	to_scheduler_arg_t (T val) noexcept

template<auto Func, typename Arg >
static constexpr void	trampoline (scheduler_arg_t raw) noexcept

template<auto Func>
static constexpr void	trampoline_no_arg (scheduler_arg_t) noexcept

Private Attributes
schfunc_t	m_callback {}

scheduler_arg_t	m_param {}

char const *	fn_name {}

Detailed Description

Definition at line 98 of file scheduler.h.

Member Typedef Documentation

◆ schfunc_t

using action_s::schfunc_t = void (*)(scheduler_arg_t)

private

Definition at line 100 of file scheduler.h.

Constructor & Destructor Documentation

◆ action_s() [1/7]

constexpr action_s::action_s	(	const schfunc_t	callback,
		char const *const	fn_name_
	)

inlineconstexprprivatenoexcept

Definition at line 108 of file scheduler.h.

108: m_callback(callback), fn_name{fn_name_} {}

action_s::m_callback

schfunc_t m_callback

Definition scheduler.h:102

action_s::fn_name

char const * fn_name

Definition scheduler.h:107

◆ action_s() [2/7]

constexpr action_s::action_s	(	const schfunc_t	callback,
		const scheduler_arg_t	param,
		char const *const	fn_name_
	)

inlineconstexprprivatenoexcept

Definition at line 109 of file scheduler.h.

109: m_callback(callback), m_param(param), fn_name{fn_name_} {}

action_s::m_param

scheduler_arg_t m_param

Definition scheduler.h:103

param

static tstrWifiInitParam param

Definition wifi_console.cpp:90

◆ action_s() [3/7]

constexpr action_s::action_s ( const schfunc_t callback )

inlineconstexprprivatenoexcept

Definition at line 111 of file scheduler.h.

111: m_callback(callback) {}

◆ action_s() [4/7]

constexpr action_s::action_s	(	const schfunc_t	callback,
		const scheduler_arg_t	param
	)

inlineconstexprprivatenoexcept

Definition at line 112 of file scheduler.h.

112: m_callback(callback), m_param(param) {}

◆ action_s() [5/7]

action_s::action_s ( )

defaultnoexcept

Referenced by make(), and make().

Here is the caller graph for this function:

◆ action_s() [6/7]

action_s::action_s ( action_s const & )

defaultnoexcept

◆ action_s() [7/7]

action_s::action_s ( action_s && other )

inlinenoexcept

Definition at line 169 of file scheduler.h.

                                        : m_callback{other.m_callback}, m_param{other.m_param}
    #if EFI_UNIT_TEST
        , fn_name {other.fn_name}
    #endif
    {
        other.m_callback = nullptr;
        other.m_param = 0;
        #if EFI_UNIT_TEST
            other.fn_name = "Moved";
        #endif
    }

Member Function Documentation

◆ execute()

void action_s::execute ( ) const

inline

Definition at line 230 of file scheduler.h.

                         {
        if (m_callback) {
            #if EFI_UNIT_TEST_VERBOSE_ACTION
                std::cout << "action_s::execute: " << fn_name << "(" << reinterpret_cast<scheduler_arg_t>(m_callback) << ") "
                "with raw arg = " << m_param << std::endl;
            #endif
            m_callback(m_param);
        } else {
            #ifdef WE_HAVE_CRITICAL_ERROR_METHOD
                efiCriticalError("clear nullptr");
            #endif
 
            #if EFI_UNIT_TEST
                assert(false);
            #endif
        }
    }

Here is the call graph for this function:

◆ from_scheduler_arg_t()

template<typename T >

static constexpr T action_s::from_scheduler_arg_t ( scheduler_arg_t raw )

inlinestaticconstexprprivatenoexcept

Definition at line 118 of file scheduler.h.

                                                                          {
        static_assert(std::is_pointer_v<T> || std::is_integral_v<T>, "Unsupported type");
        if constexpr (std::is_pointer_v<T>) {
            return reinterpret_cast<T>(raw);
        } else {
            return static_cast<T>(raw);
        }
    }

◆ getArgument()

template<typename T >

constexpr T action_s::getArgument ( ) const

inlineconstexpr

Definition at line 252 of file scheduler.h.

252{ return from_scheduler_arg_t<T>(m_param); }

◆ getArgumentRaw()

constexpr scheduler_arg_t const & action_s::getArgumentRaw ( ) const

inlineconstexpr

Definition at line 249 of file scheduler.h.

249{ return m_param; }

◆ getCallback()

constexpr schfunc_t action_s::getCallback ( ) const

inlineconstexpr

Definition at line 248 of file scheduler.h.

248{ return m_callback; }

Referenced by EventQueue::insertTask().

Here is the caller graph for this function:

◆ getCallbackName()

constexpr char const * action_s::getCallbackName ( ) const

inlineconstexpr

Definition at line 261 of file scheduler.h.

261{ return fn_name ? fn_name : "nullptr"; }

◆ make() [1/2]

template<auto Func>

static constexpr action_s action_s::make ( )

inlinestaticconstexprnoexcept

Definition at line 221 of file scheduler.h.

                                                                                                  {
        static_assert(std::is_invocable_r_v<void, decltype(Func)>, "Function signature mismatch");
        #if EFI_UNIT_TEST
            return action_s(&trampoline_no_arg<Func>, __PRETTY_FUNCTION__);
        #else
            return action_s(&trampoline_no_arg<Func>);
        #endif
    }

Here is the call graph for this function:

◆ make() [2/2]

template<auto Func, typename Arg >

static constexpr action_s action_s::make ( Arg arg )

inlinestaticconstexprnoexcept

Definition at line 196 of file scheduler.h.

                                                                                                                          {
        static_assert(std::is_invocable_r_v<void, decltype(Func), Arg>, "Function signature mismatch");
        #if EFI_UNIT_TEST_VERBOSE_ACTION
            std::cout << "action_s::make: " << __PRETTY_FUNCTION__ << "(" << reinterpret_cast<scheduler_arg_t>(Func) << ") "
            "with raw arg = " << arg << "; is_ptr = " << std::is_pointer_v<Arg> << std::endl;
        #endif
        if constexpr (std::is_pointer_v<Arg>) {
            // alignment is a must because pointers have to be dividable by 2 with no loss (i.e., no loss on bit shifts)
            // if it is 1-aligned, there will be address data in the last bit, so it cannot be used for any flags
            // There could be theoretic architectures where it is the case though I don't know what to do then,
            // Maybe introduce some other member for flag here?
            // Anyway, we have so much code relying on specific architecture, and we are not testing on some fancy
            // PowerPC/mainframe/... machines so should always be true, but just in case...
            static_assert(alignof(std::remove_pointer_t<Arg>) >= 2, "Pointer must be at least 2-aligned");
            static_assert(sizeof(scheduler_arg_t) == sizeof(void*), "Unexpected scheduler_arg_t size");
        }
        #if EFI_UNIT_TEST
            return action_s(&trampoline<Func, Arg>, to_scheduler_arg_t(arg), __PRETTY_FUNCTION__);
        #else
            return action_s(&trampoline<Func, Arg>, to_scheduler_arg_t(arg));
        #endif
    }

Here is the call graph for this function:

◆ operator bool()

constexpr action_s::operator bool ( ) const

inlineexplicitconstexpr

Definition at line 254 of file scheduler.h.

254{ return m_callback != nullptr; }

◆ operator=() [1/2]

action_s & action_s::operator= ( action_s && other )

inlinenoexcept

Definition at line 182 of file scheduler.h.

                                                   {
        m_callback = other.m_callback;
        m_param = other.m_param;
        other.m_callback = nullptr;
        other.m_param = 0;
        #if EFI_UNIT_TEST
            fn_name = other.fn_name;
            other.fn_name = "Moved";
        #endif
        return *this;
    }

◆ operator=() [2/2]

action_s & action_s::operator= ( action_s const & )

defaultnoexcept

◆ operator==()

bool constexpr action_s::operator== ( const action_s & other ) const

inlineconstexpr

Definition at line 256 of file scheduler.h.

                                                           {
        return m_callback == other.m_callback && m_param == other.m_param;
    }

◆ to_scheduler_arg_t()

template<typename T >

static constexpr scheduler_arg_t action_s::to_scheduler_arg_t ( T val )

inlinestaticconstexprprivatenoexcept

Definition at line 130 of file scheduler.h.

                                                                        {
        static_assert(std::is_pointer_v<T> || std::is_integral_v<T>, "Unsupported type");
        if constexpr (std::is_pointer_v<T>) {
            return reinterpret_cast<scheduler_arg_t>(val);
        } else {
            return static_cast<scheduler_arg_t>(val);
        }
    }

Referenced by make().

Here is the caller graph for this function:

◆ trampoline()

template<auto Func, typename Arg >

static constexpr void action_s::trampoline ( scheduler_arg_t raw )

inlinestaticconstexprprivatenoexcept

Definition at line 142 of file scheduler.h.

                                                                   {
        static_assert(std::is_pointer_v<Arg> || std::is_integral_v<Arg>, "Unsupported type");
        #if EFI_UNIT_TEST_VERBOSE_ACTION
            std::cout << "action_s::trampoline: " << __PRETTY_FUNCTION__ << "(" << reinterpret_cast<scheduler_arg_t>(Func) << ") "
            "with raw arg = " << raw << "; is_ptr = " << std::is_pointer_v<Arg> << std::endl;
        #endif
        if constexpr (std::is_pointer_v<Arg>) {
            Func(reinterpret_cast<Arg>(raw));
        } else {
            Func(static_cast<Arg>(raw));
        }
    }

◆ trampoline_no_arg()

template<auto Func>

static constexpr void action_s::trampoline_no_arg ( scheduler_arg_t )

inlinestaticconstexprprivatenoexcept

Definition at line 157 of file scheduler.h.

                                                                      {
        #if EFI_UNIT_TEST_VERBOSE_ACTION
            std::cout << "action_s::trampoline_no_arg: " << __PRETTY_FUNCTION__ << "(" << reinterpret_cast<scheduler_arg_t>(Func) << ") with no arg" << std::endl;
        #endif
        Func(); // stored argument is ignored
    }

Field Documentation

◆ fn_name

char const* action_s::fn_name {}

private

Definition at line 107 of file scheduler.h.

107{};

Referenced by execute(), getCallbackName(), and operator=().

◆ m_callback

schfunc_t action_s::m_callback {}

private

Definition at line 102 of file scheduler.h.

102{};

Referenced by action_s(), execute(), getCallback(), operator bool(), operator=(), and operator==().

◆ m_param

scheduler_arg_t action_s::m_param {}

private

Definition at line 103 of file scheduler.h.

103{};

Referenced by execute(), getArgument(), getArgumentRaw(), operator=(), and operator==().

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

controllers/system/timer/scheduler.h

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ schfunc_t

Constructor & Destructor Documentation

◆ action_s() [1/7]

◆ action_s() [2/7]

◆ action_s() [3/7]

◆ action_s() [4/7]

◆ action_s() [5/7]

◆ action_s() [6/7]

◆ action_s() [7/7]

Member Function Documentation

◆ execute()

◆ from_scheduler_arg_t()

◆ getArgument()

◆ getArgumentRaw()

◆ getCallback()

◆ getCallbackName()

◆ make() [1/2]

◆ make() [2/2]

◆ operator bool()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ to_scheduler_arg_t()

◆ trampoline()

◆ trampoline_no_arg()

Field Documentation

◆ fn_name

◆ m_callback

◆ m_param