StreamReceiverInterface.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_STREAMRECEIVERINTERFACE_HXX_
#define _OPENLCB_STREAMRECEIVERINTERFACE_HXX_
 
#include "executor/CallableFlow.hxx"
#include "openlcb/Defs.hxx"
#include "openlcb/StreamDefs.hxx"
 
template <class T> class FlowInterface;
template <class T> class Buffer;
struct ByteChunk;
using ByteBuffer = Buffer<ByteChunk>;
using ByteSink = FlowInterface<ByteBuffer>;
 
namespace openlcb
{
 
class Node;
 
struct StreamReceiveRequest : public CallableFlowRequestBase
{
    enum
    {
        OPERATION_PENDING = 0x20000,
        ERROR_CANCELED = Defs::ERROR_OUT_OF_ORDER | 1,
    };
 
    void reset()
    {
        reset_base();
        target_ = nullptr;
        localStreamId_ = StreamDefs::INVALID_STREAM_ID;
        resultCode = OPERATION_PENDING;
    }
 
    void reset(ByteSink *target, Node *dst, NodeHandle src,
        uint8_t src_stream_id = StreamDefs::INVALID_STREAM_ID,
        uint8_t dst_stream_id = StreamDefs::INVALID_STREAM_ID,
        uint16_t max_window = 0)
    {
        reset_base();
        HASSERT(target);
        target_ = target;
        src_ = src;
        dst_ = dst;
        srcStreamId_ = src_stream_id;
        localStreamId_ = dst_stream_id;
        streamWindowSize_ = max_window;
        resultCode = OPERATION_PENDING;
    }
 
    ByteSink *target_ {nullptr};
    NodeHandle src_ {0, 0};
    Node *dst_ {nullptr};
    uint8_t srcStreamId_ {StreamDefs::INVALID_STREAM_ID};
    uint8_t localStreamId_ {StreamDefs::INVALID_STREAM_ID};
    uint16_t streamWindowSize_ {0};
};
 
class StreamReceiverInterface : public CallableFlow<StreamReceiveRequest>
{
public:
    StreamReceiverInterface(Service *s)
        : CallableFlow<StreamReceiveRequest>(s)
    { }
 
    virtual void cancel_request() = 0;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_STREAMRECEIVERINTERFACE_HXX_