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
{
// @cond NODOC
namespace detail
{
 
class cTriggerItemPrioList;
 
class cTriggerPipeSourceBase : protected flash::cNamedGraphObject
{
public:
    static constexpr const char* DefaultTriggerPipeTypeName = "trigger_pipe_source";
 
public:
    cTriggerPipeSourceBase();
    cTriggerPipeSourceBase(bool bDefault, const char* strName);
    virtual ~cTriggerPipeSourceBase();

    cTriggerPipeSourceBase(const cTriggerPipeSourceBase&) = delete;
    cTriggerPipeSourceBase& operator=(const cTriggerPipeSourceBase&) = delete;
    cTriggerPipeSourceBase(cTriggerPipeSourceBase&&) = delete;
    cTriggerPipeSourceBase& operator=(cTriggerPipeSourceBase&&) = delete;
 
    // forwarding of INamedGraphObject functions
    tResult SetName(const char* strName);
    tResult SetParent(const ucom::ant::IObject* pParentObject);
    tResult GetName(base::ant::IString&& strName) const;
    tResult GetParent(const ucom::ant::IObject*& poParentObject) const;
 
    // forwarding of ITriggerPipeSource functions
    tResult RegisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                            ITriggerPipeItem::tPriority ui32Prio,
                            ITriggerPipeSource* pParent);
    tResult UnregisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                              ant::ITriggerPipeSource* pParent);
    tResult ChangePriority(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                           ITriggerPipeItem::tPriority ui32Prio);
    tResult GetSubItems(adtf::ucom::ant::iobject_enum<const ITriggerPipeItem>& lstSubItems) const;
 
protected:
    // internal functions to call the registered subitems
    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);
 
protected:
    ucom::ant::object_ptr<base::elasto::IErrorHandling::IErrorHandler> m_pErrorHandler;
 
private:
    std::unique_ptr<cTriggerItemPrioList> m_pPrioSubItems;
};
 
} // namespace detail
// @endcond

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);

template<typename... INTERFACES>
class trigger_pipe_source :
    public adtf::ucom::object<ant::ITriggerPipeSource, INTERFACES...>,
    protected detail::cTriggerPipeSourceBase
{
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
    {
        return detail::cTriggerPipeSourceBase::RegisterSubItem(pSubRun, ui32Prio, this);
    }

    tResult UnregisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun) override
    {
        return detail::cTriggerPipeSourceBase::UnregisterSubItem(pSubRun, this);
    }

    tResult ChangePriority(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                           ITriggerPipeItem::tPriority ui32Prio) override
    {
        return detail::cTriggerPipeSourceBase::ChangePriority(pSubRun, ui32Prio);
    }

    tResult GetSubItems(adtf::ucom::ant::iobject_enum<const ITriggerPipeItem>& lstSubItems) const override
    {
        return detail::cTriggerPipeSourceBase::GetSubItems(lstSubItems);
    }
 
public: // implements INamedGraphObject, if derived from it
    tResult GetName(base::ant::IString&& strName) const
    {
        return detail::cTriggerPipeSourceBase::GetName(std::forward<base::ant::IString>(strName));
    }

    tResult SetName(const char* strName)
    {
        return detail::cTriggerPipeSourceBase::SetName(strName);
    }

    tResult SetParent(const ucom::ant::IObject* oParentObject)
    {
        return detail::cTriggerPipeSourceBase::SetParent(oParentObject);
    }

    tResult GetParent(const ucom::ant::IObject*& poParentObject) const
    {
        return detail::cTriggerPipeSourceBase::GetParent(poParentObject);
    }
};
 
// @cond NODOC
namespace detail
{
 
class cTriggerPipeItemBase : public cTriggerPipeSourceBase
{
public:
    static constexpr const char* DefaultTriggerPipeTypeName = "trigger_pipe_item";
 
    cTriggerPipeItemBase();
    cTriggerPipeItemBase(const char* strName);
    ~cTriggerPipeItemBase() override;
 
    // forwarding ITriggerPipeHierachy functions
    tResult RegisterTriggerParent(const ant::ITriggerPipeSource* pParent);
    tResult UnregisterTriggerParent(const ant::ITriggerPipeSource* pParent);
    tResult GetTriggerParents(const ucom::nitro::ifunction<tResult(const ant::ITriggerPipeSource*)>& fnCallback) const;
 
    // conditionally run subs, if this item is used within a sample stream
    tResult SetRunSubsConditionally(bool bConditionally);
    bool IsRunSubsConditionally() const;
    void EnableSubRunnables();
 
    // setup the runnable trigger call that will be invoked on Run
    void SetRunnable(base::flash::IRunnable& pRunnableToCall);
    void SetRunnable(base::ant::IRunnable& pRunnableToCall);
 
    // setup any callable object as trigger call that will be invoked on Run.
    template<typename CALLABLE>
    void SetCallable(CALLABLE&& callable)
    {
        SetManagedRunnable(ucom::ucom_object_ptr_cast<ucom::IObject>(
            ucom::make_object_ptr(base::runnable(std::forward<CALLABLE>(callable)))));
    }
    void SetManagedRunnable(const ucom::object_ptr<ucom::IObject>& pRunnableToCall);
 
    // internal functions to call the registered subitems (Runnable -> RunSubs)
    tResult Run(tTimeStamp tmTimeofActivation,
                base::ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize);
 
    tResult Run(base::flash::tNanoSeconds tmTimeofActivation,
                base::ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize);
 
private:
    tResult UpdateProfilingName();
 
protected:
    base::flash::IRunnable* m_pRunnableToCall = nullptr;
    ucom::object_ptr<ucom::IObject> m_pManagedRunnable = nullptr;
 
    std::string m_strProfilingName;
    std::string m_strProfilingExecutionName;
    bool m_bRunSubsConditionally = false;
    std::atomic_bool m_bRunSubs = {true};
    std::vector<const ant::ITriggerPipeSource*> m_oDirectTriggerParents;
};
} // namespace detail
 
// @endcond

template<typename... INTERFACES>
class trigger_pipe_item :
    public adtf::ucom::catwo::object<base::ant::IRunnable,
                                     base::flash::IRunnable,
                                     ant::ITriggerPipeSource,
                                     ant::ITriggerPipeItem,
                                     quiet::ITriggerPipeHierachy,
                                     INTERFACES...>,
    protected detail::cTriggerPipeItemBase
{
public:
    trigger_pipe_item() = default;
    trigger_pipe_item(const char* strName): detail::cTriggerPipeItemBase(strName)
    {
    }

    trigger_pipe_item(const char* strName, adtf::base::ant::IRunnable& oRunnable): trigger_pipe_item(strName)
    {
        SetRunnable(oRunnable);
    }

    void SetRunnable(adtf::base::ant::IRunnable& oRunnable)
    {
        if (const auto pFlashRunnable = dynamic_cast<adtf::base::flash::IRunnable*>(&oRunnable))
        {
            SetRunnable(*pFlashRunnable);
        }
        else
        {
            detail::cTriggerPipeItemBase::SetRunnable(oRunnable);
        }
    }

    void SetRunnable(adtf::base::flash::IRunnable& oRunnable)
    {
        detail::cTriggerPipeItemBase::SetRunnable(oRunnable);
    }

    template<typename CALLABLE>
    void SetCallable(CALLABLE&& callable)
    {
        detail::cTriggerPipeItemBase::SetCallable(std::forward<CALLABLE>(callable));
    }
 
    // implementation of trigger pipe source
    tResult RegisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                            ITriggerPipeItem::tPriority ui32Prio) override
    {
        return detail::cTriggerPipeItemBase::RegisterSubItem(pSubRun, ui32Prio, this);
    }

    tResult UnregisterSubItem(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun) override
    {
        return detail::cTriggerPipeItemBase::UnregisterSubItem(pSubRun, this);
    }

    tResult ChangePriority(const adtf::ucom::ant::iobject_ptr<ITriggerPipeItem>& pSubRun,
                           ITriggerPipeItem::tPriority ui32Prio) override
    {
        return detail::cTriggerPipeSourceBase::ChangePriority(pSubRun, ui32Prio);
    }

    tResult GetSubItems(adtf::ucom::ant::iobject_enum<const ITriggerPipeItem>& lstSubItems) const override
    {
        return detail::cTriggerPipeSourceBase::GetSubItems(lstSubItems);
    }
 
    // implementation of trigger pipe item and its IRunnable interface
    tResult Run(tTimeStamp tmTimeofActivation,
                adtf::base::ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize) override
    {
        return detail::cTriggerPipeItemBase::Run(tmTimeofActivation, ui32ActivationType, pvUserData, nUserDataSize);
    }
 
    // implementation of flash::IRunnable interface
    tResult Run(adtf::base::flash::tNanoSeconds tmTimeofActivation,
                adtf::base::ant::IRunnable::tActivationType ui32ActivationType,
                const void* pvUserData,
                size_t nUserDataSize) override
    {
        return detail::cTriggerPipeItemBase::Run(tmTimeofActivation, ui32ActivationType, pvUserData, nUserDataSize);
    }
 
    // implementation of trigger pipe hierachy interface
    tResult RegisterTriggerParent(const ant::ITriggerPipeSource* pParent) override
    {
        return detail::cTriggerPipeItemBase::RegisterTriggerParent(pParent);
    }

    tResult UnregisterTriggerParent(const ant::ITriggerPipeSource* pParent) override
    {
        return detail::cTriggerPipeItemBase::UnregisterTriggerParent(pParent);
    }

    tResult GetTriggerParents(
        const ucom::nitro::ifunction<tResult(const ant::ITriggerPipeSource*)>& fnCallback) const override
    {
        return detail::cTriggerPipeItemBase::GetTriggerParents(fnCallback);
    }
 
    // implement named graph object interface if derived from it
    tResult GetName(base::ant::IString&& strName) const
    {
        return detail::cTriggerPipeSourceBase::GetName(std::forward<base::ant::IString>(strName));
    }

    tResult SetName(const char* strName)
    {
        return detail::cTriggerPipeSourceBase::SetName(strName);
    }

    tResult SetParent(const ucom::ant::IObject* oParentObject)
    {
        return detail::cTriggerPipeSourceBase::SetParent(oParentObject);
    }

    tResult GetParent(const ucom::ant::IObject*& poParentObject) const
    {
        return detail::cTriggerPipeSourceBase::GetParent(poParentObject);
    }
};
 
} // namespace streaming
} // namespace adtf