Header for Data layer

//
//  Mediator.h
//  Chess
//
//  Created by Nevin Flanagan on 3/28/12.
//  Copyright (c) 2012. All rights reserved.
//

#ifndef Chess_Mediator_h
#define Chess_Mediator_h

#include <exception>
#include <map>
#include <list>
#include "Connection.h"

using namespace std;

class HostMediator {
public:
    class Acceptor{
    protected:
        typedef enum {
            connection_lost,
            packet_ready,
            packet_acknowledged
        } event;
        friend class HostMediator;
    public:
        class Generator {
        public:
            virtual Acceptor& operator()(RemoteHost::Receptionist::Generator& creator) = 0;
            virtual ~Generator() {}
        };

        virtual void operator() (HostMediator&, event) = 0;
        virtual ~Acceptor() {};
    };

    class DeadConnection: public exception {
    public:
        DeadConnection(HostMediator&);
    };

    class TimeoutExpired: public exception {};

    struct Transmission {
        Transmission();
        Transmission(unsigned short len,
                     char const bytes[]);
        unsigned short length;
        char data[256];
    };

    HostMediator(std::string const& targetAddress, int targetPort,
               Acceptor& localProcessor, float errorRate = 0.0f);

    HostMediator& transmit(Transmission const&,
                           bool reliable = true) throw (DeadConnection);
    HostMediator& transmit(Transmission const&, float timeout,
                           bool reliable = true) throw (DeadConnection, TimeoutExpired);

    HostMediator& collect(Transmission&)
        throw (DeadConnection);
    HostMediator& collect(Transmission&, float timeout)
        throw (DeadConnection, TimeoutExpired);
    static RemoteHost::Acceptor& supportHost(int socketID);
private:
    static char const DATA_LEADER = 0x01;
    static char const ACK_LEADER = 0x06;
    static char const NACK_LEADER = 0x15;

    typedef unsigned long long packetID;

    class SlidingWindow: private list< pair<unsigned char, RemoteHost::Transmission*> > {
    public:
        SlidingWindow(unsigned char size = 1) {reset(1);}
        void reset(unsigned char size);
        void extend(unsigned char size);
        bool includes(unsigned char index);
        bool contains(unsigned char index);
        RemoteHost::Transmission*& operator[](unsigned char index);
        bool operator>>(RemoteHost::Transmission*&);
        list<unsigned char> missing();
    };

    class SendBuffer: public HostMediator::Transmission {
    public:
        SendBuffer(packetID sendingPacket, Transmission const&);
        unsigned char nextSequence() const {return sequenceNumber;}
        bool operator>>(RemoteHost::Transmission&);
        packetID const ID;
    private:
        char *buffer;
        unsigned char sequenceNumber;
    };
    class ReceiveBuffer: public HostMediator::Transmission {
    public:
        ReceiveBuffer(packetID receivingPacket, unsigned short declaredLength);
        unsigned char nextSequence() const {return sequenceNumber;}
        bool operator<<(RemoteHost::Transmission const&);
        packetID const ID;
    private:
        char *buffer;
        unsigned char sequenceNumber;
    };
    class ConnectionManager: public RemoteHost::Acceptor {
    public:
        class Generator: public RemoteHost::Receptionist::Generator {
        public:
            RemoteHost::Acceptor& operator()(int);
            Generator(HostMediator::Acceptor::Generator& source);
        private:
            HostMediator::Acceptor::Generator& generator;
        };

        static RemoteHost::Acceptor& supportHost(int socketID);
        ConnectionManager(HostMediator::Acceptor&);
        ConnectionManager(HostMediator&);
        void operator() (RemoteHost&, event);

    private:
        HostMediator* mediator;
        HostMediator* allocated;
        HostMediator::Acceptor& acceptor;
    };

    HostMediator(RemoteHost& link,
               Acceptor& localProcessor);

    RemoteHost& partner;
    HostMediator::Acceptor& processor;

    unsigned int sendWindowSize, receiveWindowSize;
    list<RemoteHost::Transmission*> sendingBuffers;
    list<RemoteHost::Transmission*> receivingBuffers;
    SlidingWindow sendingWindow, receivingWindow;
    ReceiveBuffer* incoming;
    list<SendBuffer*> outgoingQueue;
    list<HostMediator::Transmission*> incomingQueue;
    packetID sendingID, receivingID, completedID, completedReceipt;

    static unsigned long checksum(HostMediator::Transmission const&);
    static unsigned long checksum(RemoteHost::Transmission const&);
    bool sendFrame();
    RemoteHost::Transmission& nack(RemoteHost::Transmission& refusal, bool valid = true);
    RemoteHost::Transmission& ack(RemoteHost::Transmission& complete);
    RemoteHost::Transmission& ack(RemoteHost::Transmission& complete, unsigned char index);

    RemoteHost::Transmission& processFrame(RemoteHost::Transmission&);
    RemoteHost::Transmission& processACK(RemoteHost::Transmission&);
    RemoteHost::Transmission& processNACK(RemoteHost::Transmission&);

};

#endif