test_runtime.h

Go to the documentation of this file.

#ifndef _ADTF_UCOM_ANT_TESTING_RUNTIME_INCLUDES_HEADER_
#define _ADTF_UCOM_ANT_TESTING_RUNTIME_INCLUDES_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace testing
{
namespace ant
{
typedef enum : int8_t
{
    RL_Shutdown = IRuntime::RL_Shutdown,
    RL_System = 1,
    RL_Application = 2,
    RL_Running = 3
} tTestRL;

class cTestRuntime : public adtf::ucom::runtime<tTestRL::RL_Running>
{
    typedef adtf::ucom::runtime<tTestRL::RL_Running> base_type;
 
public:
    cTestRuntime(): base_type()
    {
    }
};

const adtf_util::cFilename find_plugin(const adtf::util::cString& strPluginName);

const adtf_util::cFilename load_plugin(const adtf::util::cString& strPluginName, int8_t ui8Level, ucom::ant::IRuntime& oRuntime);

const adtf_util::cFilename load_plugin(const adtf::util::cString& strPluginName, int8_t ui8Level);

const adtf_util::cFilename load_plugin(const adtf::util::cString& strPluginName);
void load_service(const adtf_util::cString& strPluginName, const adtf_util::cString& strClassId,
                   const adtf_util::cString& strObjectId,
                   int8_t nPluginLevel,
                   int8_t nServiceLevel);

void load_service(const adtf_util::cString& strPluginName, const adtf_util::cString& strClassId,
                   const adtf_util::cString& strObjectId,
                   int8_t nServiceLevel);

void clean_up();

class cExecutorThread
{
    private:
        std::thread m_oThread;
        std::mutex m_oActionMutex;
        typedef std::function<void()> action_type;
        action_type m_fnAction;
        bool m_bQuitThread = false;
        std::condition_variable m_oNewAction;
 
    public:
        cExecutorThread()
        {
            m_oThread = std::thread([&]
            {
                std::unique_lock<std::mutex> oLocker(m_oActionMutex);
                for (;;)
                {
                    m_oNewAction.wait(oLocker, [&]
                    {
                       return m_fnAction || m_bQuitThread;
                    });
 
                    if (m_bQuitThread)
                    {
                        return;
                    }
 
                    m_fnAction();
                    m_fnAction = action_type();
                }
            });
        }
 
        ~cExecutorThread()
        {
            {
                std::lock_guard<std::mutex> oLocker(m_oActionMutex);
                m_bQuitThread = true;
            }
 
            m_oNewAction.notify_one();
            m_oThread.join();
        }
 
        tResult Execute(std::function<tResult()> fnAction)
        {
            std::promise<tResult> oPromisedResult;
            auto oResult = oPromisedResult.get_future();
 
            {
                std::lock_guard<std::mutex> oLocker(m_oActionMutex);
                m_fnAction = [&]
                {
                    oPromisedResult.set_value(fnAction());
                };
            }
 
            m_oNewAction.notify_one();
            return oResult.get();
        }
};

template<typename RuntimeClass>
class exec_forward
{
    private:
        std::unique_ptr<RuntimeClass> m_pRuntime;
 
    public:
        exec_forward():
            m_pRuntime(new RuntimeClass)
        {
            _runtime = m_pRuntime.get();
        }
 
        ~exec_forward()
        {
            m_pRuntime->SetRunLevel(adtf::ucom::ant::IRuntime::RL_Shutdown, true);
            _runtime = nullptr;
        }
 
        tResult Exec(std::function<void()> fnStartup)
        {
            return m_pRuntime->Exec(adtf::ucom::ant::IRuntime::RL_Shutdown + 1,
                                    fnStartup);
        }
};

template<typename ExecuteForward>
class runtime_executor: private cExecutorThread
{
    private:
        std::unique_ptr<ExecuteForward> m_pExecuteForward;
        std::thread m_oExecWaitThread;
 
    public:
        ~runtime_executor()
        {
            if (m_oExecWaitThread.joinable())
            {
                m_oExecWaitThread.join();
            }
        }
 
        tResult Create()
        {
            return Execute([&]() -> tResult
            {
                m_pExecuteForward.reset(new ExecuteForward());
                RETURN_NOERROR;
            });
        }
 
        tResult Start()
        {
            if (m_oExecWaitThread.joinable())
            {
                RETURN_ERROR(ERR_INVALID_STATE);
            }
 
            std::promise<tResult> oExecLoopStarted;
            auto oStarted = oExecLoopStarted.get_future();
            m_oExecWaitThread = std::thread([&]
            {
                Execute([&]() -> tResult
                {
                    auto nExecResult = m_pExecuteForward->Exec([&]
                    {
                        oExecLoopStarted.set_value(ERR_NOERROR);
                    });
 
                    if (IS_FAILED(nExecResult))
                    {
                        oExecLoopStarted.set_value(nExecResult);
                    }
                    RETURN_NOERROR;
                });
            });
 
            return oStarted.get();
        }
};
 
 
}//ns ant
 
using ant::tTestRL;
using ant::cTestRuntime;
 
using ant::find_plugin;
using ant::load_plugin;
using ant::load_service;
using ant::clean_up;
 
using ant::exec_forward;
using ant::runtime_executor;
 
}//ns testing
}//ns ucom
}//ns adtf
 
#endif // _ADTF_UCOM_ANT_TESTING_RUNTIME_INCLUDES_HEADER_