streaming_sink.h

Go to the documentation of this file.

#pragma once
#include "runtime_behaviour.h"
#include "streaming_source.h"
#include "streaming_sink_intf.h"
#include "data_binding.h"
#include "named_graph_object.h"
#include "interface_binding.h"
#include "interface_binding_object.h"
 
namespace adtf
{
namespace streaming
{
namespace ant
{
class cSampleStreamingSink:
    public cRuntimeBehaviour,
    public streaming_level_machine,
    public ucom::catwo::object<ucom::ant::cClassInfo,
                               base::ant::configuration<>,
                               IDynamicDataBinding,
                               IStreamingService,
                               IStreamingSink,
                               data_binding<named_graph_object<ISampleStreamingSink>>>
{
 
private:
    A_UTILS_D(cSampleStreamingSink)
 
public:
    cSampleStreamingSink();
    cSampleStreamingSink(const char* strName);
    virtual ~cSampleStreamingSink();
 
public:
    tResult SetState(tStreamingState eState) override;
    IStreamingSink::tStreamingState GetState() override;
 
    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;
 
    using cDataBinding::RegisterPin;
    tResult RegisterPin(const ucom::ant::iobject_ptr<IPin>& pPin);
 
 
 
    tResult Destruct() override;
    tResult StartStreaming() override;
    tResult StopStreaming() override;
 
public:
    using cRuntimeBehaviour::RegisterRunner;
    using cRuntimeBehaviour::RegisterInnerPipe;
};
}
 
namespace catwo
{
    class cSampleStreamingSink :
        public ucom::catwo::object<ant::cSampleStreamingSink, 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(cSampleStreamingSink& oStreamingSink,
        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(oStreamingSink.RegisterBindingObject(pBindingServer));
        RETURN_NOERROR;
    }

    template<typename INTERFACE>
    tResult create_client(cSampleStreamingSink& oStreamingSink, 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(oStreamingSink.RegisterBindingObject(pBindingClient));
        RETURN_NOERROR;
    }
 
}
 
 
using catwo::cSampleStreamingSink;
 
}
}