runnable.h

Go to the documentation of this file.

#pragma once
#include "runnable_intf.h"
#include <adtfucom3/adtf_ucom3.h>
 
namespace adtf
{
namespace base
{
template<ant::IRunnable::tActivationType DEFAULT_ACTIVATION_TYPE = ant::IRunnable::RUN_UNSPECIFIED,
         typename ANT_INTERFACE = ant::IRunnable,
         typename FLASH_OR_ANT_INTERFACE = flash::IRunnable,
         typename CALLABLE = flash::IRunnable::tRunFunction>
class runnable : public ucom::object<ant::IRunnable, flash::IRunnable, ANT_INTERFACE, FLASH_OR_ANT_INTERFACE>
{
    static_assert(std::disjunction_v<
                      // bind expression → accept immediately, no is_invocable_r_v ever instantiated because MSVC
                      // limitations here to check type of parameters
                      std::is_bind_expression<std::decay_t<CALLABLE>>,
                      std::is_invocable_r<tResult, std::decay_t<CALLABLE>>,
                      std::is_invocable_r<tResult, std::decay_t<CALLABLE>, tNanoSeconds>,
                      std::is_invocable_r<tResult, std::decay_t<CALLABLE>, tTimeStamp>,
                      std::is_invocable_r<tResult,
                                          std::decay_t<CALLABLE>,
                                          tNanoSeconds,
                                          ant::IRunnable::tActivationType,
                                          const void*,
                                          size_t>>,
                  "Instantiation of runnable requires a callable with a compatible signature: "
                  "tResult(void) or tResult(tNanoSeconds) or tResult(tTimeStamp) or "
                  "tResult(tNanoSeconds, ant::IRunnable::tActivationType, const void*, size_t)");
 
    static_assert(std::is_base_of_v<ant::IRunnable, ANT_INTERFACE>,
                  "ANT_INTERFACE template parameter at runnable<DEFAULT_ACTIVATION_TYPE, ANT_INTERFACE, "
                  "FLASH_OR_ANT_INTERFACE, CALLABLE> must be derived from ant::IRunnable");
 
    static_assert(std::is_base_of_v<flash::IRunnable, FLASH_OR_ANT_INTERFACE> ||
                      std::is_base_of_v<ant::IRunnable, FLASH_OR_ANT_INTERFACE>,
                  "FLASH_OR_ANT_INTERFACE template parameter at runnable<DEFAULT_ACTIVATION_TYPE, ANT_INTERFACE, "
                  "FLASH_OR_ANT_INTERFACE, CALLABLE> must be derived from flash::IRunnable or ant::IRunnable");
 
protected:
    std::decay_t<CALLABLE> m_fcRunFunc;
 
public:
    runnable() = delete;

    runnable(CALLABLE&& fcRunFunc) noexcept:
        m_fcRunFunc(std::forward<CALLABLE>(fcRunFunc)), m_ui32ActivationType(DEFAULT_ACTIVATION_TYPE)
    {
    }

    template<typename CALLABLE_WITH_TIMSTAMP,
             typename CALLABLE_TYPE = CALLABLE,
             std::enable_if_t<std::is_same_v<std::decay_t<CALLABLE_TYPE>, flash::IRunnable::tRunFunction> &&
                                  std::is_invocable_r_v<tResult, std::decay_t<CALLABLE_WITH_TIMSTAMP>, tTimeStamp>,
                              bool> = true>
    runnable(CALLABLE_WITH_TIMSTAMP&& fcRunFunc) noexcept:
        m_fcRunFunc(
            [fcRunFunc = std::forward<CALLABLE_WITH_TIMSTAMP>(fcRunFunc)](tNanoSeconds tmTrigger) noexcept -> tResult
            {
                RETURN_IF_FAILED(fcRunFunc(duration_cast<tTimeStamp>(tmTrigger)));
                RETURN_NOERROR;
            }),
        m_ui32ActivationType(DEFAULT_ACTIVATION_TYPE)
    {
    }

    runnable(CALLABLE&& fcRunFunc, ant::IRunnable::tActivationType ui32ActivationType) noexcept:
        m_fcRunFunc(std::forward<CALLABLE>(fcRunFunc)), m_ui32ActivationType(ui32ActivationType)
    {
    }

    ~runnable() override = default;

    tResult Run(tTimeStamp tmTimeofActivation,
                ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize) override
    {
        return Run(duration_cast<tNanoSeconds>(tmTimeofActivation), ui32ActivationType, pvUserData, nUserDataSize);
    }

    tResult Run(tNanoSeconds tmTimeofActivation,
                ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize) override
    {
        if (m_ui32ActivationType == ui32ActivationType || m_ui32ActivationType == ant::IRunnable::RUN_UNSPECIFIED)
        {
            tResult oResult = ERR_NOT_INITIALIZED;
            if constexpr (std::is_invocable_r_v<tResult, CALLABLE, tNanoSeconds, ant::IRunnable::tActivationType,
                                                const void*, size_t>)
            {
                oResult = m_fcRunFunc(tmTimeofActivation, ui32ActivationType, pvUserData, nUserDataSize);
            }
            else if constexpr (std::is_invocable_r_v<tResult, CALLABLE, tTimeStamp>)
            {
                (void) pvUserData; // touch to avoid unused parameter warning
                (void) nUserDataSize;
                oResult = m_fcRunFunc(duration_cast<tTimeStamp>(tmTimeofActivation));
            }
            else if constexpr (std::is_invocable_r_v<tResult, CALLABLE, tNanoSeconds>)
            {
                (void) pvUserData; // touch to avoid unused parameter warning
                (void) nUserDataSize;
                oResult = m_fcRunFunc(tmTimeofActivation);
            }
            else if constexpr (std::is_invocable_r_v<tResult, CALLABLE>)
            {
                (void) tmTimeofActivation; // touch to avoid unused parameter warning
                (void) ui32ActivationType;
                (void) pvUserData;
                (void) nUserDataSize;
                oResult = m_fcRunFunc();
            }
            RETURN_IF_FAILED(oResult);
            RETURN_NOERROR;
        }
        RETURN_ERROR(ERR_INVALID_ARG);
    }

    ant::IRunnable::tActivationType GetActivationType() const override
    {
        return m_ui32ActivationType;
    }
 
private:
    ant::IRunnable::tActivationType m_ui32ActivationType = ant::IRunnable::RUN_UNSPECIFIED;
};

template<typename CALLABLE, typename... ARGS>
runnable(CALLABLE&&, ARGS&&...)
    -> runnable<ant::IRunnable::RUN_UNSPECIFIED, ant::IRunnable, flash::IRunnable, CALLABLE&&>;
 
namespace ant
{
template<ant::IRunnable::tActivationType DEFAULT_ACTIVATION_TYPE = ant::IRunnable::RUN_UNSPECIFIED,
         typename ANT_INTERFACE = ant::IRunnable,
         typename CALLABLE = ant::IRunnable::tRunFunction>
using runnable = adtf::base::runnable<DEFAULT_ACTIVATION_TYPE, ANT_INTERFACE, flash::IRunnable, CALLABLE>;
} // namespace ant

#define ADTF_RUN_FUNCTION(_fcName_)      \
    [this](tTimeStamp tmTime) -> tResult \
    {                                    \
        return _fcName_(tmTime);         \
    }

#define ADTF_RUN_FUNCTION_NS(_fcName_)                        \
    [this](adtf::base::flash::tNanoSeconds tmTime) -> tResult \
    {                                                         \
        return _fcName_(tmTime);                              \
    }
 
} // namespace base
} // namespace adtf