Stream.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_STREAM_HXX_
#define _OPENLCB_STREAM_HXX_
 
#include "openlcb/NMRAnetIf.hxx"
#include "utils/RBTree.hxx"
#include "utils/RingBuffer.hxx"
 
namespace openlcb
{
 
class Stream
{
public:
    static const size_t CHANNELS_PER_NODE;
    
    static const uint16_t MAX_BUFFER_SIZE;
 
    typedef void *StreamHandle;
    
    StreamHandle sopen(NodeHandle dst, long long timeout);
 
    void sclose(StreamHandle handle);
 
    ssize_t swrite(StreamHandle handle, const void *buf, size_t size);
 
    ssize_t sread(StreamHandle handle, void *buf, size_t size);
 
protected:
    Stream()
        : outboundTree(),
          inboundTree(),
          count(0),
          sem()
    {
    }
    
    ~Stream()
    {
    }
 
    void packet(Defs::MTI mti, NodeHandle src, Buffer *data);
 
private:
    enum Flag
    {
        PERMINATE_ERROR = 0x40, 
        ACCEPT          = 0x80  
    };
    
    enum State
    {
        PENDING_O,   
        WAITING_O,   
        CONNECTED_O, 
        CLOSED_O,    
        PENDING_I,   
        WAITING_I,   
        CONNECTED_I, 
        CLOSED_I,    
    };
    
    enum Protocol
    {
        DISCOVER_1     = 0x0600000000000000,
        DISCOVER_2     = 0x0500000000000000,
        DISCOVER_3     = 0x0400000000000000,
        DISCOVER_4     = 0x0300000000000000,
        DISCOVER_5     = 0x0200000000000000,
        DISCOVER_6     = 0x0100000000000000,
        DISCOVERED     = 0x0000000000000000,
        DISCOVERED_DEC = 0x0100000000000000,
        DISCOVER_MASK  = 0xFF00000000000000,
        DISCOVER_SHIFT = 56,
    };
    
    struct Metadata
    {
        uint64_t protocol; 
        RingBuffer<uint8_t> *data; 
        NodeHandle  nodeHandle; 
        size_t  size;   
        size_t  count;  
        State   state;  
        uint8_t srcID;  
        uint8_t dstID;  
    };
 
    virtual int write(Defs::MTI mti, NodeHandle dst, Buffer *data) = 0;
 
    virtual BufferQueueWait *rx_queue() = 0;
 
    void initiate_request(NodeHandle src, Buffer *buffer);
 
    void initiate_reply(NodeHandle src, Buffer *buffer);
 
    void handle_data(NodeHandle src, Buffer *buffer);
 
    void proceed(NodeHandle src, Buffer *buffer);
 
    void complete(NodeHandle src, Buffer *buffer);
    
    RBTree <uint8_t, Metadata*> outboundTree;
 
    RBTree <uint8_t, Metadata*> inboundTree;
 
    size_t count;
 
    OSSem sem;
 
    DISALLOW_COPY_AND_ASSIGN(Stream);
};
 
struct IdStreamType
{
    Stream::StreamHandle stream;
};
 
 
};
 
#endif // _OPENLCB_STREAM_HXX_