runtime.h

Go to the documentation of this file.

 
#pragma once
 
#include <a_utils.h>
#include <adtfucom3/interfaces/object_intf.h>
#include <adtfucom3/object_ptr/object_ptr_intf.h>
#include <adtfucom3/object.h>
#include <adtfucom3/interfaces/class_info_intf.h>
#include <adtfucom3/interfaces/plugin_info_intf.h>
#include <adtfucom3/interfaces/class_factory_intf.h>
#include <adtfucom3/interfaces/runtime_intf.h>
#include <functional>
 
namespace adtf
{
namespace ucom
{
namespace ant
{
namespace detail
{
class tRuntimeResult : public tResult
{
    protected:
        
        tRuntimeResult(const tRuntimeResult&) = delete;
        tRuntimeResult& operator=(const tRuntimeResult&) = delete;
        tRuntimeResult& operator=(tRuntimeResult&&) = delete;
 
    public:
        tRuntimeResult() = delete;
        tRuntimeResult(const tResult& oResultToDeepCopy) : tResult(oResultToDeepCopy.GetErrorCode(),
                                                                   oResultToDeepCopy.GetDescription(),
                                                                   oResultToDeepCopy.GetLine(),
                                                                   oResultToDeepCopy.GetFile(),
                                                                   oResultToDeepCopy.GetFunction())
        {
        }
        tRuntimeResult(tResult&& oResultToDeepCopy) : tResult(oResultToDeepCopy.GetErrorCode(),
                                                              oResultToDeepCopy.GetDescription(),
                                                              oResultToDeepCopy.GetLine(),
                                                              oResultToDeepCopy.GetFile(),
                                                              oResultToDeepCopy.GetFunction())
        {
        }
 
        tRuntimeResult(tRuntimeResult&& oResultToDeepCopy) : tRuntimeResult(static_cast<tResult&&>(oResultToDeepCopy))
        {
        }
 
        tRuntimeResult& operator=(const tResult& oResultToDeepCopy)
        {
            //create a copy
            tRuntimeResult oCopyResult(oResultToDeepCopy);
            //move the copy
            tResult::operator=(static_cast<tResult>(oCopyResult));
            return *this;
        }
};
class DOEXPORT cRuntime : public catwo::object<IRuntime>
{
    A_UTILS_D(cRuntime);
 
    public:
        cRuntime(int8_t nLastRunlevel);
 
        cRuntime(int8_t nLastRunlevel, const adtf::util::cCommandLine& oCommandline);
 
    protected:
        virtual ~cRuntime();
 
        virtual const char* GetRunLevelString(int8_t i8Runlevel) const = 0;
 
        virtual tResult ChangeRunLevel(int8_t i8RunLevelToChangeTo);
 
        tResult CallRuntimeHooks(int nHookId,
                                 uint32_t ui32Param1=0,
                                 uint32_t ui32Param2=0,
                                 void* pvData=NULL,
                                 int szData=0,
                                 const iobject_ptr<IObject>& pObject=object_ptr<IObject>());
 
        tResult NotifyAllObjects(int nEventId,
                                 uint32_t ui32Param1=0,
                                 uint32_t ui32Param2=0,
                                 void* pvData=NULL,
                                 int szData=0,
                                 bool bBackwards=false);
 
        void SetEventFilter(std::function<tResult(int, uint32_t, uint32_t, void*, int,  const iobject_ptr<IObject>&)> fnHookFilter,
                            std::function<tResult(int, uint32_t, uint32_t, void*, int, bool)> fnEventFilter);
 
        bool StartedCompletedImplementation() const;
 
    public:
        tResult Exec(int8_t i8FirstRunlevelToChange, std::function<void()> fnStartup);
 
    public: // implements IRuntime
 
        // runlevel control
        tResult SetRunLevel(int8_t i8RunlevelToChangeTo, bool bWait=true) override;
 
        int8_t GetRunLevel() const override;
 
        // object registry
        tResult RegisterObject(const iobject_ptr<IObject>& pObject,
                               const char* strNameOID,
                               int8_t nRunLevel,
                               uint32_t ui32Flags = 0) override;
 
        tResult UnregisterObject(const iobject_ptr<IObject>& pObject,
                                 const tChar* strNameOID = "") override;
        tResult GetObjects(iobject_enum<IObject>& lstOfObjects) const override;
 
        // plugin registry
        tResult RegisterPlugin(const char* strUrl,
                               int8_t nRunLevel,
                               iobject_ptr<IPluginInfo>& pPluginInfo,
                               uint32_t ui32Flags=0) override;
 
        tResult UnregisterPlugin(const iobject_ptr<IPluginInfo>& pPluginInfo, uint32_t ui32Flags = 0) override;
 
        tResult UnregisterAllPlugins(int8_t nRunLevel, uint32_t ui32Flags = 0) override;
 
        tResult GetPlugins(iobject_enum<const IPluginInfo>& lstPluginInfos) const override;
 
        // class registry
        tResult RegisterClassFactory(const iobject_ptr<const IClassFactory>& pClassFactory,
                                     uint32_t ui32Flags=0) override;
        tResult UnregisterClassFactory(const iobject_ptr<const IClassFactory>& pClassFactory) override;
 
        tResult GetClasses(iobject_enum<const IClassInfo>& lstOfClasses) const override;
        tResult GetClassFactories(iobject_enum<const IClassFactory>& lstOfClasses) const override;
 
        tResult RegisterHook(IRuntimeHook& pHook) override;
 
        tResult UnregisterHook(IRuntimeHook& pHook) override;
 
        // Get an object from the object registry
        tResult GetObject(iobject_ptr<IObject>& pObject, const char* strNameOID) const override;
        tResult GetObject(iobject_ptr<IObject>& pObject) const override;
 
        // Create an instance of a concrete type
        tResult CreateInstance(const char* strCID,
                               iobject_ptr<IObject>& oObject,
                               const tChar* strNameOfObject = "") const override;
 
 
};//class cRuntime
 
template<int8_t LAST_RUN_LEVEL>
class runtime : public cRuntime
{
public:
    runtime() : cRuntime(LAST_RUN_LEVEL)
    {
    }
    runtime(const adtf::util::cCommandLine& oCommandline) : cRuntime(LAST_RUN_LEVEL, oCommandline)
    {
    }
 
    const char* GetRunLevelString(int8_t /* i8Runlevel */) const override
    {
        return "";
    }
};
 
 
 
} // namespace detail
 
using detail::runtime;
 
} // namespace ant
 
namespace spider
{
namespace detail
{
template<int8_t LAST_RUN_LEVEL>
class runtime : public catwo::object<ant::runtime<LAST_RUN_LEVEL>, spider::IRuntimeStartup>
{
public:
    using base_type = catwo::object<ant::runtime<LAST_RUN_LEVEL>, spider::IRuntimeStartup>;
    using base_type::base_type;
 
    bool StartupCompleted() const override
    {
        return this->StartedCompletedImplementation();
    }
};
 
}
 
using detail::runtime;
 
}
 
using spider::runtime;
 
 
} // namespace ucom
} // namespace adtf