streaming_source.h

Go to the documentation of this file.

#pragma once
 
#include "streaming_source_intf.h"
#include "runtime_behaviour.h"
#include "data_binding.h"
#include "named_graph_object.h"
#include "interface_binding.h"
#include "interface_binding_object.h"
#include <adtfbase/exception_handling.h>
 
namespace adtf
{
namespace streaming
{
namespace ant
{

class  streaming_level_machine : public adtf::ucom::level_machine < streaming_level_machine,
    IStreamingService::tStreamingState,
    IStreamingService::tStreamingState::State_Shutdown >
{
protected:
    streaming_level_machine() = default;
    streaming_level_machine(const streaming_level_machine&) = delete;
    streaming_level_machine(streaming_level_machine&&) = delete;
    streaming_level_machine& operator=(const streaming_level_machine&) = delete;
    streaming_level_machine& operator=(streaming_level_machine&&) = delete;
 
protected:
    tResult SetLevel(IStreamingService::tStreamingState eStreamingState)
    {
        RETURN_IF_FAILED((ChangeLevel<
                              handler<IStreamingService::tStreamingState::State_Constructed, Inc, &streaming_level_machine::Construct>,
                              handler<IStreamingService::tStreamingState::State_Initialized, Inc, &streaming_level_machine::Init>,
                              handler<IStreamingService::tStreamingState::State_Streaming, Inc, &streaming_level_machine::StartStreaming>,
 
                              handler<IStreamingService::tStreamingState::State_Initialized, Dec, &streaming_level_machine::StopStreaming>,
                              handler<IStreamingService::tStreamingState::State_Constructed, Dec, &streaming_level_machine::Shutdown>,
                              handler<IStreamingService::tStreamingState::State_Shutdown, Dec, &streaming_level_machine::Destruct>
                          >(eStreamingState)));
 
        RETURN_NOERROR;
    }
 
protected:

    virtual tResult Construct()
    {
        RETURN_NOERROR;
    }

    virtual tResult Destruct()
    {
        RETURN_NOERROR;
    }

    virtual tResult Init()
    {
        RETURN_NOERROR;
    }

    virtual tResult Shutdown()
    {
        RETURN_NOERROR;
    }

    virtual tResult StartStreaming()
    {
        RETURN_NOERROR;
    }

    virtual tResult StopStreaming()
    {
        RETURN_NOERROR;
    }
};

class cSampleStreamingSource:
    public cRuntimeBehaviour,
    public streaming_level_machine,
    public ucom::catwo::object<ucom::ant::cClassInfo,
                               base::ant::configuration<>,
                               IDynamicDataBinding,
                               IStreamingService,
                               IStreamingSource,
                               data_binding<named_graph_object<ISampleStreamingSource>>>
{
 
 
public:
    cSampleStreamingSource() = default;
    cSampleStreamingSource(const char* strName)
    {
        named_graph_object::SetName(strName);
    }
    virtual ~cSampleStreamingSource()
    {
        data_binding::ReleasePins();
    }
 
public:
    tResult SetState(IStreamingSource::tStreamingState eState) override;
    IStreamingSource::tStreamingState GetState() override;
 
    using cDataBinding::RegisterPin;
    tResult RegisterPin(const ucom::ant::iobject_ptr<IPin>& pPin);
 
    tResult RequestPin(const char* strName,
                       const adtf::ucom::ant::iobject_ptr<const IStreamType>& pType,
                       adtf::ucom::ant::iobject_ptr<IInPin>& pInPin) override;
    tResult RequestPin(const char* strName,
                       const adtf::ucom::ant::iobject_ptr<const IStreamType>& pType,
                       adtf::ucom::ant::iobject_ptr<IOutPin>& pOutPin) override;
   
    tResult Destruct() override;
 
    tResult StartStreaming() override;
    tResult StopStreaming() override;    
};
 
}
namespace catwo
{
    class cSampleStreamingSource :
        public ucom::catwo::object<ant::cSampleStreamingSource, interface_binding<>>
    {
    public:
        using cInterfaceBinding::RegisterBindingObject;
        tResult RegisterBindingObject(const ucom::ant::iobject_ptr<IBindingObject>& pBindingObject) override
        {
            RETURN_IF_POINTER_NULL(pBindingObject.Get());
 
            pBindingObject.Get()->SetParent(static_cast<INamedGraphObject*>(this));
 
            return cInterfaceBinding::RegisterBindingObject(pBindingObject);
        }
 
    };

    template<typename INTERFACE>
    tResult create_server(cSampleStreamingSource& oStreamingSource,
        const char* strServerName,
        const adtf::ucom::iobject_ptr<INTERFACE>& pServerInterface)
    {
        using namespace adtf::ucom;
        object_ptr<IBindingServer> pBindingServer = make_object_ptr<cBindingServer>(strServerName,
            object_ptr<const IBindingType>(make_object_ptr<binding_type<INTERFACE>>()),
            ucom_object_ptr_cast<IObject>(pServerInterface));
        RETURN_IF_FAILED(oStreamingSource.RegisterBindingObject(pBindingServer));
        RETURN_NOERROR;
    }

    template<typename INTERFACE>
    tResult create_client(cSampleStreamingSource& oStreamingSource, const char* strClientName)
    {
        using namespace adtf::ucom;
        object_ptr<IBindingClient> pBindingClient = make_object_ptr<cBindingClient>(strClientName,
            object_ptr<const IBindingType>(make_object_ptr<binding_type<INTERFACE>>()));
        RETURN_IF_FAILED(oStreamingSource.RegisterBindingObject(pBindingClient));
        RETURN_NOERROR;
    }
 
}
 
using catwo::cSampleStreamingSource;
 
}
}