requestable_writer.h

Go to the documentation of this file.

#pragma once
#include <adtfstreaming3/samplewriter.h>
#include <adtfstreaming3/interface_binding_type.h>
#include <adtfstreaming3/interface_binding_proxy_intf.h>
#include <adtfstreaming3/streamingrequests_intf.h>
#include <adtfucom3/adtf_ucom3.h>
#include <adtf_utils.h>
#include <memory>
#include <functional>
 
namespace adtf
{
namespace streaming
{
namespace hollow
{

class cRequestBroker: public ucom::object<IStreamingRequests>
{
    public:
        cRequestBroker(cSampleWriter* pWriter = nullptr);

        ~cRequestBroker() override;

        void SetCallbacks(std::function<void(uint32_t, const base::IProperties*)> fnEnable,
                           std::function<void(uint32_t)> fnDisable);

        void UpdateType(const ucom::ant::iobject_ptr<const IStreamType>& pType);

        void DisableCurrentRequests(bool bCallDisableCallback = false);
 
        // IStreamingRequests implementation
        tResult RequestSamples(ucom::ant::iobject_ptr<IStreamingRequest>& pRequest,
                               uint32_t nSubStreamId,
                               const base::ant::IProperties* pRequestProperties = nullptr) override;
        void RegisterStreamTypeHandler(IStreamTypeHandler& oHandler) override;
        void UnregisterStreamTypeHandler(IStreamTypeHandler& oHandler) override;
 
    private:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};

template <typename BaseWriter = adtf::streaming::cSampleWriter>
class writer_with_request_broker:
    public BaseWriter
{
    public:
        void SetBroker(const ucom::ant::iobject_ptr<IStreamingRequests>& pBroker)
        {
            m_pBroker.Reset(pBroker);
        }
 
        tResult BeginStreaming(streaming::ant::ISampleStream& oSampleStream) override
        {
            auto pHollowStream = ucom::ucom_cast<IInternalBindingProxy*>(&oSampleStream);
            RETURN_IF_POINTER_NULL_DESC(pHollowStream, "Sample Stream does not implement IInternalBindingProxy");
            RETURN_IF_FAILED(pHollowStream->GetInternalBindingProxy(m_pProxy));
            ucom::object_ptr<IBindingType> pType = ucom::make_object_ptr<binding_type<IStreamingRequests>>();
            RETURN_IF_FAILED(m_pProxy->BindServerObject(m_pBroker, pType));
 
            return BaseWriter::BeginStreaming(oSampleStream);
        }
 
        tResult EndStreaming() override
        {
            BaseWriter::EndStreaming();
            if (m_pProxy)
            {
                m_pProxy->UnbindServerObject(m_pBroker);
                m_pProxy.Reset();
            }
            RETURN_NOERROR;
        }
 
    private:
        ucom::ant::object_ptr<IStreamingRequests> m_pBroker;
        ucom::ant::object_ptr<ant::IBindingProxy> m_pProxy;
};

template <typename BaseWriter = adtf::streaming::cSampleWriter>
class requestable_writer: public writer_with_request_broker<BaseWriter>
{
    public:
        requestable_writer():
            m_pBroker(ucom::make_object_ptr<cRequestBroker>(this))
        {
            writer_with_request_broker<BaseWriter>::SetBroker(ucom::ucom_object_ptr_cast<IStreamingRequests>(m_pBroker));
        }

        void SetCallbacks(std::function<void(uint32_t, const base::IProperties*)> fnEnable,
                           std::function<void(uint32_t)> fnDisable)
        {
            m_pBroker->SetCallbacks(fnEnable, fnDisable);
        }
 
        tResult SetType(const ucom::ant::iobject_ptr<const ant::IStreamType>& pType) override
        {
            m_pBroker->UpdateType(pType);
            return BaseWriter::SetType(pType);
        }
 
        tResult ChangeType(const ucom::ant::iobject_ptr<const ant::IStreamType>& pType) override
        {
            return ChangeType(pType, true, false);
        }

        tResult ChangeType(const ucom::ant::iobject_ptr<const ant::IStreamType>& pType,
                           bool bDisableCurrentRequests,
                           bool bCallDisableCallback)
        {
            RETURN_IF_FAILED(ChangeType(pType, bDisableCurrentRequests, bCallDisableCallback, true));
            RETURN_IF_FAILED(ChangeType(pType, false, false, false));
            RETURN_NOERROR;
        }
 
        tResult ChangeType(const ucom::ant::iobject_ptr<const ant::IStreamType>& pType,
                           bool bDisableCurrentRequests,
                           bool bCallDisableCallback,
                           bool bSync)
        {
            if (bDisableCurrentRequests)
            {
                m_pBroker->DisableCurrentRequests(bCallDisableCallback);
            }
 
            if (bSync)
            {
                m_pBroker->UpdateType(pType);
            }
            else
            {
                RETURN_IF_FAILED(BaseWriter::ChangeType(pType));
            }
 
            RETURN_NOERROR;
        }
 
        tResult EndStreaming() override
        {
            writer_with_request_broker<BaseWriter>::EndStreaming();
            m_pBroker->DisableCurrentRequests(false);
            RETURN_NOERROR;
        }
 
    private:
        ucom::ant::object_ptr<cRequestBroker> m_pBroker;
 
};
 
}
 
using hollow::requestable_writer;
 
}
}