ConnectionSender.h

#pragma once

#include "Connection.h"

#define RECV_RATE_SET_SIZE  4

class CConnectionSender : public CConnection
{
public:
    enum EResult
    {
        SEND_SUCCESS = 0,
        SEND_FAIL_NOT_OPEN = 1
    };

    enum EStateSender
    {
        IDLE = 0,
        SENDING = 1
    };

private:
    typedef queue<CPacket*> TBufferQueue;
    typedef map<__uint32, CPacket*>
                            TBufferMap;

    // State
    EStateSender            stateSender;

    // Buffer
    TBufferQueue            bufferTx;                   // transmission buffer (packets to be tranmitted)
    TBufferMap              bufferAck;                  // acknowledgment buffer (packets transmitted but now acknowledged, either received or lost)
    TBufferQueue            bufferRtx;                  // retransmission buffer (packets acknowledged as lost)

    // Flow
    __time                  flowRtt;                    // round-trip time
    __time                  flowRto;                    // retransmission time-out
    __time                  flowTld;                    // list-time doubled

    __uint32                flowMss;                    // flow maximum segment size in bits
    __bitrate               flowRate;                   // flow rate (bps)
    __bitrate               flowRateBps;                // flow rate calculated with TCP throughput equation
    __bitrate               flowInitialRate;            // flow initial rate (bps)

    double                  flowLossRate;               // flow last reported loss rate (p)

    __uint32                flowPacketSequence;
    __uint32                flowPacketId;
    __uint32                flowPacketSize;

    static double           flowThroughputFunction[];   // flow throughput function f(p)
    static __time           flowMaximumBackoffInterval;

    bool                    flowIdleNoFeedback;

    // Data-limited interval
    __time                  dliNotLimited1;
    __time                  dliNotLimited2;
    __time                  dliTimeNew;
    __time                  dliTimeNext;

    // Receiver
    __bitrate               recvRateSet[RECV_RATE_SET_SIZE];
    __byte                  recvRateSetFirst;
    __byte                  recvRateSetLast;

    // Timers
    CTimer<CConnectionSender>*
                            timerNoFeedback;
    CTimer<CConnectionSender>*
                            timerSender;

    // Functions
    void                    (CConnectionSender::*functionSender)();

    // Events
    Event2<void, CConnectionSender*, CPacket*>* eventSend;

public:
    CConnectionSender(
        __uint32                                                            idEntry,
        __uint16                                                            port,
        CSimHandler*                                                        sim,
        IDelegate5<void, __uint16, __uint16, CAddress, __byte, CPacket*>*   delegateSend,
        IDelegate1<void, CConnection*>*                                     delegateDispose,
        CAddress                                                            remoteAddress,
        __uint16                                                            remotePort,
        __uint32                                                            remoteId,
        __uint32                                                            remoteIdEntry,
        __uint32                                                            segmentSize
        );
    virtual ~CConnectionSender();

    // Send
    EResult             Send(CPacket* packet);

    // Event send
    inline Event2<void, CConnectionSender*, CPacket*>*
        EventSend() { return this->eventSend; }

    // Stat
    inline __time       StatFlowRtt() { return this->flowRtt; }
    inline __bitrate    StatFlowRate() { return this->flowRate; }
    inline double       StatFlowLossRate() { return this->flowLossRate; }

    char*               ToString() const;
private:
    // Receive
    virtual void        Recv(CPacketConnection* packet);
    virtual void        RecvData(CPacketConnectionData* packet) { /* do nothing */ }
    virtual void        RecvFeedback(CPacketConnectionFeedback* packet);

    // Timers
    void                TimerNoFeedback(CTimerInfo* info);
    void                TimerSender(CTimerInfo* info);

    void                TimerSenderIdle();
    void                TimerSenderSending();

    // Congestion control
    void                UpdateLimits(__bitrate limit);
};