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);
};
class cADTFSystem final {…};
 
}
 
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>;
 
} // ant
 
using ant::create_adtf_default_system;
using ant::system_executor;
 
} // testing 
} // 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);
        }
};
class exec_forward<adtf::system::ant::cADTFSystem> {…};
 
}  //ant
}  //testing
}  //ucom
}  //adtf