triggerpipe.h

Go to the documentation of this file.

 
#pragma once
#include "triggerpipe_intf.h"
#include "named_graph_object_intf.h"
#include "named_graph_object.h"
#include "graph.h"
 
#include <adtfbase/runnable_intf.h>
#include <adtfbase/error_handling_intf.h>
 
namespace adtf
{
namespace streaming
{
namespace ant
{
    namespace detail
    {
        class cTriggerPipeSourceImpl
        {
        private:
            A_UTILS_D(cTriggerPipeSourceImpl);
 
        public:
            cTriggerPipeSourceImpl();
            virtual ~cTriggerPipeSourceImpl() = default;
 
        private:
            cTriggerPipeSourceImpl(const cTriggerPipeSourceImpl&) = delete;
            cTriggerPipeSourceImpl& operator=(const cTriggerPipeSourceImpl&) = delete;
            cTriggerPipeSourceImpl(cTriggerPipeSourceImpl&&) = delete;
            cTriggerPipeSourceImpl& operator=(cTriggerPipeSourceImpl&&) = delete;
 
        protected:
            static adtf::base::IRunnable* m_pNothingToDoRunnable;
 
        public:
            tResult RegisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                                    ITriggerPipeItem::tPriority ui32Prio);
            tResult UnregisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun);
            tResult ChangePriority(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                                   ITriggerPipeItem::tPriority ui32Prio);
            tResult GetSubItems(adtf::ucom::ant::iobject_enum<const ITriggerPipeItem>& lstSubItems) const;
 
            tResult RunSubs(tTimeStamp tmTimeofActivation,
                            adtf::base::ant::IRunnable::tActivationType ui32ActivationType,
                            const void* pvUserData,
                            size_t nUserDataSize);
 
            tResult RunSubs(base::flash::tNanoSeconds tmTimeofActivation,
                            adtf::base::ant::IRunnable::tActivationType ui32ActivationType,
                            const void* pvUserData,
                            size_t nUserDataSize);
        };
    } //detail
 
    template <typename INTERFACE = ITriggerPipeSource>
    class trigger_pipe_source: public adtf::ucom::catwo::object<ITriggerPipeSource, INTERFACE>,
                               protected detail::cTriggerPipeSourceImpl
    {
        public:
            trigger_pipe_source() = default;
 
            virtual ~trigger_pipe_source() = default;
 
        public: //implements ITriggerPipeSource
            tResult RegisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                                    ITriggerPipeItem::tPriority ui32Prio) override
            {
                #ifdef _DEBUG
                    INamedGraphObject* pNamedFar  = adtf::ucom::ant::ucom_cast<INamedGraphObject*>(pSubRun.Get());
                    INamedGraphObject* pNamedThis = adtf::ucom::ucom_cast<INamedGraphObject*>(this);
                    adtf_util::cString strFullNameTo("unkonwn");
                    if (pNamedFar)
                    {
                        strFullNameTo = get_named_graph_object_full_name(*pNamedFar);
                    }
                    adtf_util::cString strFullName("unkonwn");
                    if (pNamedThis)
                    {
                        strFullName = get_named_graph_object_full_name(*pNamedThis);
                    }
                    LOG_DUMP("Runner connecting:  %s -> %s", strFullName.GetPtr(), strFullNameTo.GetPtr());
                #endif //_DEBUG
                RETURN_IF_FAILED(check_loop_call_in_trigger_pipe(*this));
                return detail::cTriggerPipeSourceImpl::RegisterSubItem(pSubRun, ui32Prio);
            }
            tResult UnregisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun) override
            {
                return detail::cTriggerPipeSourceImpl::UnregisterSubItem(pSubRun);
            }
            tResult ChangePriority(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                                   ITriggerPipeItem::tPriority ui32Prio) override
            {
                return detail::cTriggerPipeSourceImpl::ChangePriority(pSubRun, ui32Prio);
            }
            tResult GetSubItems(adtf::ucom::ant::iobject_enum<const ITriggerPipeItem>& lstSubItems) const override
            {
                return detail::cTriggerPipeSourceImpl::GetSubItems(lstSubItems);
            }
 
    };
 
    
    template <typename INTERFACE = ITriggerPipeItem>
    class trigger_pipe_item : public adtf::ucom::catwo::object<ITriggerPipeItem, trigger_pipe_source<INTERFACE>>
    {
        public:
            typedef trigger_pipe_source<INTERFACE> _base_type;
 
        private:
            adtf::base::ant::IRunnable* m_pRunnable = _base_type::m_pNothingToDoRunnable;
            adtf::ucom::ant::object_ptr<adtf::base::elasto::IErrorHandling::IErrorHandler> m_pErrorHandler;
         
        public:
            trigger_pipe_item() = default;
            trigger_pipe_item(const char* strName) : _base_type(strName)
            {                
            }
            trigger_pipe_item(const char* strName, adtf::base::ant::IRunnable& oRunnable) : trigger_pipe_item(strName)
            {
                SetRunnable(oRunnable);
            }
 
            tResult SetFullName(const char* strName)
            {
                m_pErrorHandler = adtf::base::elasto::create_error_handler(strName,
                                                                           "runner_pipe_error",
                                                                           adtf::base::elasto::IErrorHandling::tAction::Stop);
                RETURN_NOERROR;
            }
        
            tResult Run(tTimeStamp tmTimeofActivation,
                        adtf::base::ant::IRunnable::tActivationType ui32ActivationType,
                        const void* pvUserData,
                        size_t nUserDataSize) override
            {
                //ask for return value ??? and what to to with that ?
                //if somebody return an error this will break the whole runnerpipe  
                auto oResult = m_pRunnable->Run(tmTimeofActivation, ui32ActivationType, pvUserData, nUserDataSize);
                if (IS_FAILED(oResult) && m_pErrorHandler)
                {
                    m_pErrorHandler->Handle(oResult);
                }
                return detail::cTriggerPipeSourceImpl::RunSubs(tmTimeofActivation, ui32ActivationType, pvUserData, nUserDataSize);
            }
 
        public:
            void SetRunnable(adtf::base::ant::IRunnable& oRunnable)
            {
                m_pRunnable = &oRunnable;
            }
    };
 
    tResult create_trigger_pipe(const char* strNameOfPipe,
                               adtf::ucom::ant::iobject_ptr<ITriggerPipe>& pTriggerPipe,
                               adtf::ucom::ant::object_list<ITriggerPipeItem> lstNextItems);
 
    tResult check_loop_call_in_trigger_pipe(const adtf::streaming::ant::ITriggerPipeSource& pItem);
 
} //namespace ant
 
namespace flash
{
 
#define ADTF_FLASH_NAMED_GRAPH_OBJECT_METHOD_DECLARATIONS \
public:\
    tResult GetName(base::ant::IString&& strName) const override;\
    tResult SetName(const char* strName) override;\
    tResult SetParent(const ucom::ant::IObject* oParentObject) override;\
    tResult GetParent(const ucom::ant::IObject*& poParentObject) const override;
 
#define ADTF_FLASH_TRIGGER_PIPE_SOURCE_METHOD_DECLARATIONS \
public:\
    tResult RegisterSubItem(const ucom::ant::iobject_ptr<streaming::ant::ITriggerPipeItem>& pSubRun,\
                            streaming::ant::ITriggerPipeSource::tPriority ui32Prio) override;\
    tResult UnregisterSubItem(const ucom::ant::iobject_ptr<streaming::ant::ITriggerPipeItem>& pSubRun) override;\
    tResult ChangePriority(const ucom::ant::iobject_ptr<streaming::ant::ITriggerPipeItem>& pSubRun,\
                           streaming::ant::ITriggerPipeSource::tPriority ui32Prio) override;\
    tResult GetSubItems(ucom::ant::iobject_enum<const streaming::ant::ITriggerPipeItem>& lstSubItems) const override;
 
#define ADTF_FLASH_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS \
public:\
    tResult Run(tTimeStamp tmTimeofActivation,\
                base::ant::IRunnable::tActivationType ui32ActivationType,\
                const void* pvUserData,\
                size_t nUserDataSize) override;\
    tResult Run(base::flash::tNanoSeconds tmTimeofActivation,\
                base::ant::IRunnable::tActivationType ui32ActivationType,\
                const void* pvUserData,\
                size_t nUserDataSize) override;\
public:\
    ADTF_FLASH_TRIGGER_PIPE_SOURCE_METHOD_DECLARATIONS \
    ADTF_FLASH_NAMED_GRAPH_OBJECT_METHOD_DECLARATIONS
 
}
 
namespace quiet
{
 
#define ADTF_QUIET_TRIGGER_PIPE_ITEM_METHOD_DECLARATIONS \
public:\
    tResult RegisterTriggerParent(const streaming::ant::ITriggerPipeSource* pParent) override;\
    tResult UnregisterTriggerParent(const streaming::ant::ITriggerPipeSource* pParent) override;\
    tResult GetTriggerParents(const ucom::nitro::ifunction<tResult(const streaming::ant::ITriggerPipeSource*)>& fnCallback) const override;
}
 
using ant::trigger_pipe_source;
using ant::trigger_pipe_item;
 
using ant::create_trigger_pipe;
using ant::check_loop_call_in_trigger_pipe;
} //namespace streaming
} //namespace adtf