Transport.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 __TRANSPORT_H__
#define __TRANSPORT_H__

#include <string>

namespace RNReplicaNet
{

const int TransportAnyGameChannel = 0;
const int TransportMinimumPacketSize = 512;

class Transport
{
public:

    enum Error
    {
        kTransport_EOK = 0,                     
        kTransport_EERROR = -1,                 
        kTransport_ECANTLISTENONCHANNEL = -2,   
        kTransport_EWAITING = -3                
    };

    enum Bandwidth
    {
        kBandwidth_Off = 0,
        kBandwidth_Connection = 1
    };

    Transport();

    virtual ~Transport();

    /* These virtual functions have a base implementation but can also be replaced by a new transport if needed */

    virtual int GetPacketsSent(const bool reset = false);

    virtual int GetPacketsSentMerged(const bool reset = false);

    virtual int GetPacketsSentSize(const bool reset = false);

    virtual int GetPacketsReceived(const bool reset = false);

    virtual int GetPacketsReceivedMerged(const bool reset = false);

    virtual int GetPacketsReceivedSize(const bool reset = false);

    virtual int GetPacketsLost(const bool reset = false);

    virtual void SetBandwidthLimit(const Bandwidth enable = kBandwidth_Off);

    virtual Bandwidth GetBandwidthLimit();

    virtual void SetMaximumOutputBandwidth(const int bytesPerSecond = 0);

    virtual int GetMaximumOutputBandwidth(void);

    virtual void SetMaximumInputBandwidth(const int bytesPerSecond = 0);

    virtual int GetMaximumInputBandwidth(void);

    virtual std::string GetPeerURL(void);

    virtual bool GetTransportClosed(void);

    virtual void SetEnableLANDiscovery(const bool enable = true);

    virtual bool GetEnableLANDiscovery(void);

    /* These pure virtual functions are the minimum feature set the transport has to support */

    virtual std::string CanAccept(void) = 0;

    virtual std::string CanRoute(void) = 0;

    virtual std::string ExportURL(void) = 0;

    virtual Transport *Allocate(void) = 0;

    virtual Error Listen(const int channel = TransportAnyGameChannel) = 0;

    virtual Error Listen(const std::string &address) = 0;

    virtual Error Connect(const std::string address) = 0;

    virtual Transport *Accept(void) = 0;

    virtual Error Send(const char *data,const int len) = 0;

    virtual Error SendOrdered(const char *data,const int len,const unsigned int band = 0) = 0;

    virtual Error SendReliable(const char *data,const int len,const unsigned int band = 0) = 0;

    virtual Error SendCertain(const char *data,const int len) = 0;

    virtual int Recv(char *const data,const int maxlen) = 0;

    virtual int GetMaxPacketSize(void) = 0;

    virtual std::string HandleDiscovery(void) = 0;

    virtual void HandleDiscoveryReply(const std::string reply) = 0;

    virtual void BeginDiscovery(void) = 0;

    virtual std::string GetNextDiscovery(void) = 0;

    virtual Error GetStatus(void) = 0;

    int GetInstance(void);

    virtual void SetTransparentPacketCompression(const int level = 0)
    {
    }

    virtual int GetTransparentPacketCompression(void)
    {
        return 0;
    }

private:
    int mTransportInstance;
};

} // namespace RNReplicaNet

#endif