adtf_system.h

Go to the documentation of this file.

#pragma once
#include <adtfbase/adtf_runtime.h>

#define SESSION_MANAGER_DEFAULT_NAME "session_manager.system.adtf"
#define LOGGING_DEFAULT_NAME "logging.system.adtf"
#define RPC_OBJECT_REGISTRY_DEFAULT_NAME "rpc_object_server_registry.system.adtf"
#define SAMPLE_STREAM_TRACER_DEFAULT_NAME "sample_stream_tracer.system.adtf"
#define MACRO_RESOLVER_DEFAULT_NAME "macro_resolver.system.adtf"
 
namespace adtf
{
namespace system
{
namespace ant
{

class cADTFSystem final
{
    A_UTILS_D(cADTFSystem)
 
protected:
    cADTFSystem(const cADTFSystem&) = delete;
    cADTFSystem& operator=(const cADTFSystem&) = delete;
    cADTFSystem(cADTFSystem&&) = delete;
    cADTFSystem& operator=(cADTFSystem&&) = delete;
 
public:
    cADTFSystem();
    ~cADTFSystem();

    void EnableSessionManagerCreation(bool bEnable = true);

    void EnableLogging(bool bEnable = true);

    void EnableRPCObjectRegistry(bool bEnable = true);

    void EnableMacroResolver(bool bEnable = true);

    void EnableProfiler(bool bEnable = true, unsigned int nPort = 28077, const char* strDumpFile = nullptr);

    void EnableSampleStreamTracer(bool bEnable = true);

    void EnableAutoQuit(bool bEnable = true, base::tADTFRunLevel eLevel = base::tADTFRunLevel::RL_Running);

    void SetSessionManagerCID(const util::cString& strSessionManagerCID);

    void SetADTFDIR(const util::cFilename& strADTFDIR);

    void SetADTFCorePlugin(const util::cFilename& strCorePluginPath);

    void SetLoggingParameter(unsigned int nStdOutLogLevel,
                             unsigned int nStdErrLogLevel,
                             unsigned int nDebugLogLevel,
                             tTimeStamp tmQueueProcessingInterval);

    void SetLoggingParameter(unsigned int nStdOutMinLogLevel,
                             unsigned int nStdOutMaxLogLevel,
                             unsigned int nStdErrMinLogLevel,
                             unsigned int nStdErrMaxLogLevel,
                             unsigned int nDebugMinLogLevel,
                             unsigned int nDebugMaxLogLevel,
                             tTimeStamp tmQueueProcessingInterval);

    void SetAdditionalInitFunction(std::function<tResult()> fnInitFunction);

    void SetRPCURL(const util::cString& strRPCUrl);

    tResult Launch(adtf::ucom::ant::IRuntime& oRuntime);

    tResult Launch(const adtf::util::cCommandLine& oCommandLine);

    tResult Exec(int8_t nFirstRunLevel, const adtf::util::cCommandLine& oCommandLine, std::function<void()> fnStartup);
    tResult Exec(int8_t nFirstRunLevel,
                 const adtf::util::cCommandLine& oCommandLine,
                 std::function<void()> fnStartup,
                 bool bContinueInCaseOfError);

    tResult ExecMicro(adtf::base::quiet::IADTFRuntime::tADTFMicroRunLevel nFirstMicroRunLevel,
                      const adtf::util::cCommandLine& oCommandLine,
                      std::function<void()> fnStartup,
                      bool bContinueInCaseOfError);
};
 
} // namespace ant
 
using ant::cADTFSystem;
 
namespace testing
{
namespace ant
{

tResult create_adtf_default_system(const adtf::util::cFilename& strCorePlugin = adtf::util::cFilename(),
                                   bool bLogging = false,
                                   const adtf::util::cString& strRPCURL = adtf::util::cString(),
                                   bool bProfiler = false,
                                   unsigned int nProfilingPort = 28077);
 
template<typename T>
using system_executor = adtf::ucom::testing::ant::runtime_executor<T>;
 
} // namespace ant
 
using ant::create_adtf_default_system;
using ant::system_executor;
 
} // namespace testing
} // namespace system
 
namespace ucom
{
namespace testing
{
namespace ant
{
 
template<>
class exec_forward<adtf::system::ant::cADTFSystem>
{
private:
    std::unique_ptr<adtf::system::ant::cADTFSystem> m_pSystem;
 
public:
    exec_forward(): m_pSystem(new adtf::system::ant::cADTFSystem())
    {
        tResult nLaunchResult = m_pSystem->Launch(adtf::util::cCommandLine());
        A_UTILS_ASSERT(nLaunchResult.IsOk());
    }
 
    ~exec_forward()
    {
        if (m_pSystem)
        {
            _runtime->SetRunLevel(adtf::base::ant::tADTFRunLevel::RL_Shutdown, true);
        }
    }
 
    tResult Exec(std::function<void()> fnStartup)
    {
        return m_pSystem->Exec(adtf::base::ant::tADTFRunLevel::RL_System, adtf::util::cCommandLine(), fnStartup);
    }
};
 
} // namespace ant
} // namespace testing
} // namespace ucom
} // namespace adtf