ConnectionReceiver.h

#pragma once

#include "Connection.h"

#define MAX_LOSS_EVENTS 8

class CConnectionReceiver : public CConnection
{
private:
    struct SLossEvent
    {
        __time      firstLossTime;
        __uint32    firstLossSequence;
    };

    /*
     * For performance reasons, the loss packets history is implemented as a FIFO queue and the receiver does not check if an out-of-order
     * packet has been previously added (it is not possible to have out-of-order packets). Otherwise, it is possible that a receiver might
     * report the same packet as both acknowledged and loss at the same time. If the implementation will support out of order packets,
     * such a check mush be made either at the receiver or at the sender (better).
     */
    typedef map<__uint32, __time>   THistoryRecv;
    typedef queue<__uint32>         THistoryLoss;                           

    // Delegate
    IDelegate2<void, CConnectionReceiver*, CPacket*>*
                            delegateRecv;

    // Flow
    double                  flowLossRate;
    __bitrate               flowRateRecv;
    __time                  flowRtt;
    __uint32                flowSequenceLast;       // last received sequence number
    __time                  flowTimeLast;           // last received time
    
    __time                  timeTxLast;             // transmit time of last received data packet
    __time                  timeRxLast;             // receive time of last received data packet
    __time                  timeFeedbackLast;       // last expiration of the feedback timer
    
    // Timers
    CTimer<CConnectionReceiver>*
                            timerFeedback;

    // Receive function
    void                    (CConnectionReceiver::*recvData)(CPacketConnectionData*);

    // History
    THistoryRecv            historyRecv;
    THistoryLoss            historyLoss;

    // Loss
    SLossEvent              lossEvents[MAX_LOSS_EVENTS];
    __byte                  lossEventFirst;
    __byte                  lossEventLast;
    __byte                  lossEventCount;
    static double           lossIntervalWeigth[MAX_LOSS_EVENTS];
    __uint32                lossSequenceLast;
    double                  lossPrevInterval0;
    double                  lossPrevInterval1;
    double                  lossPrevWeigth;

    __uint32                recvSize;

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

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

    // Timers
    void            TimerFeedback(CTimerInfo* info);
};