runnable.h

Go to the documentation of this file.

 
#pragma once
#include "runnable_intf.h"
#include <adtfucom3/adtf_ucom3.h>
 
namespace adtf
{
namespace base
{
namespace ant
{
 
 
class cRunnable : public adtf::base::ant::IRunnable
{
 
    protected:
        cRunnable(const cRunnable&) = delete;
        cRunnable(cRunnable&&) = delete;
        cRunnable& operator=(const cRunnable&) = delete;
        cRunnable& operator=(cRunnable&&) = delete;
 
    public:
        cRunnable();
        virtual ~cRunnable();
 
    public:
        tResult Run(tTimeStamp tmTimeofActivation,
                    tActivationType ui32ActivationType,
                    const void* pvUserData,
                    size_t nUserDataSize) override;
};
 
template<IRunnable::tActivationType TYPE_OF_ACTIVATION = IRunnable::RUN_UNSPECIFIED, typename Interface = IRunnable>
class runnable : public ucom::catwo::object<IRunnable, Interface>
{
protected:
    IRunnable::tRunFunction m_fcRunOnceFunc = nullptr;
 
public:
    runnable() {}
    runnable(IRunnable::tRunFunction fcRunOnceFunc) : runnable()
    {
        m_fcRunOnceFunc = fcRunOnceFunc;
    }
    virtual ~runnable() = default;
 
    tResult Run(tTimeStamp tmTimeofActivation,
                IRunnable::tActivationType ui32ActivationType,
                const void* /* pvUserData */,
                size_t /* nUserDataSize */) override
    {
        if (ui32ActivationType == TYPE_OF_ACTIVATION
            || TYPE_OF_ACTIVATION == IRunnable::RUN_UNSPECIFIED)
        {
            tResult nErrorCode = ERR_NOT_INITIALIZED;
            if (m_fcRunOnceFunc)
            {
                nErrorCode = m_fcRunOnceFunc(tmTimeofActivation);
            }
            
            return nErrorCode;
        }
        RETURN_ERROR(ERR_INVALID_ARG);
    }
 
    virtual IRunnable::tActivationType GetActivationType() const
    {
        return TYPE_OF_ACTIVATION;
    }
};
 
} //namespace ant
 
namespace flash
{
 
template<ant::IRunnable::tActivationType TYPE_OF_ACTIVATION = ant::IRunnable::RUN_UNSPECIFIED, typename AntInterface = ant::IRunnable, typename Interface = IRunnable>
class runnable : public ucom::catwo::object<ant::IRunnable, AntInterface, IRunnable, Interface>
{
protected:
    adtf::base::flash::IRunnable::tRunFunction m_fcRunOnceFunc = nullptr;
 
public:
    runnable() = default;
    runnable(adtf::base::flash::IRunnable::tRunFunction fcRunOnceFunc) : runnable()
    {
        m_fcRunOnceFunc = fcRunOnceFunc;
    }
 
    runnable(ant::IRunnable::tRunFunction fcRunOnceFunc) : runnable()
    {
        m_fcRunOnceFunc = [fcRunOnceFunc](tNanoSeconds tmTimeofActivation) -> tResult
        {
            return fcRunOnceFunc(duration_cast<tTimeStamp>(tmTimeofActivation));
        };
    }
 
    ~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 (ui32ActivationType == TYPE_OF_ACTIVATION
            || TYPE_OF_ACTIVATION == ant::IRunnable::RUN_UNSPECIFIED)
        {
            tResult nErrorCode = ERR_NOT_INITIALIZED;
            if (m_fcRunOnceFunc)
            {
                nErrorCode = m_fcRunOnceFunc(tmTimeofActivation);
            }
 
            return nErrorCode;
        }
        RETURN_ERROR(ERR_INVALID_ARG);
    }
 
    ant::IRunnable::tActivationType GetActivationType() const override
    {
        return TYPE_OF_ACTIVATION;
    }
};
 
}
 
#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); }
 
 
using ant::cRunnable;
using flash::runnable;
 
 
} //namespace base
} // namespace adtf