BaseTransportServer.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef _BASETRANSPORTSERVER_H_
#define _BASETRANSPORTSERVER_H_
#include <map>
#include "RNPlatform/Inc/SysTime.h"
#include "RNPlatform/Inc/Encryption.h"
#include "RNPlatform/Inc/ThreadClass.h"
#include "RNPlatform/Inc/Thread.h"
#include "RNXPURL/Inc/Transport.h"
#include "RNPlatform/Inc/MessageHelper.h"
#include "RNLobby/Inc/CommonServer.h"

namespace RNReplicaNet
{

namespace RNLobby
{

class BaseTransportServer : private CommonServer , public ThreadClass , public Thread
{
public:
    BaseTransportServer();
    virtual ~BaseTransportServer();

    void SetEncryptionKey(const void *data,const int length);

    virtual bool StartWithTransport(Transport *transport,const bool allowDelete = true,const bool isListen = true);

    virtual bool Stop(void);

    static SysTimeType FloatTime(void);

    size_t GetNumConnections(void) const;

    size_t GetNumTotalSessions(void) const;

    bool SetAsDisconnecting(Transport *transport);

protected:
    struct Entry
    {
        Entry() : mLastPacketTime(0.0f) , mLastPacketsSent(0) , mWaitingForDisconnect(-1.0f) , mError(false) ,
            mClientACKConnectionNonce(false) , mCachedConnectionNonce(0) {}
        SysTimeType mLastPacketTime;
        int mLastPacketsSent;
        SysTimeType mWaitingForDisconnect;
        bool mError;
        bool mClientACKConnectionNonce;
        int mCachedConnectionNonce;
    };

    virtual bool CallbackParseValidMessage(Transport *transport,DynamicMessageHelper &message,const size_t length) { return true; }

    virtual bool PackageAndSendData(Transport *transport,const DynamicMessageHelper &message);

    virtual bool CallbackParsePacketData(Transport *transport,void *data,size_t &length,DynamicMessageHelper &result,Entry &entry);

    virtual void CallbackAccepted(Transport *transport) {}

    virtual void CallbackDisconnected(Transport *transport) {}

    virtual void CallbackDataReceived(DynamicMessageHelper &message) {}

    virtual void CallbackDataSend(DynamicMessageHelper &message) {}

    virtual void CallbackQueryReplyTime(const float seconds) {}

    virtual bool CallbackPoll(void) { return true; }

    virtual void CallbackTidy(void) {}

    int ThreadEntry(void);

    void GenerateNewNonce(void);

private:

    void ThreadExiting(const int returnCode);
    void Tidy(void);

    int RunThink(Transport *transport,Entry &entry);

protected:
    Transport *mTransport;
    bool mAllowDelete;

    int mNOnce;
    std::map<Transport*,Entry> mConnected;

    bool mIsListen;
    bool mClientGotAPacket;
    bool mClientIsStable;

    Entry mClientEntry;

    size_t mNumConnections;
    size_t mNumTotalConnections;

    int GetConnectionNOnce(Transport *transport = 0, const Entry *entry = 0);

    int CalculateConnectionNOnce(Transport *transport);

    const Entry *FindEntry(Transport *transport);
};

} // namespace RNLobby

} // namespace RNReplicaNet

#endif