framework.h

/***************************************************************************
 * The contents of this file are subject to the Mozilla Public             *
 * License Version 1.1 (the "License"); you may not use this file          *
 * except in compliance with the License. You may obtain a copy of         *
 * the License at http://www.mozilla.org/MPL/                              *
 *                                                                         *
 * Software distributed under the License is distributed on an "AS         *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or              *
 * implied. See the License for the specific language governing            *
 * rights and limitations under the License.                               *
 *                                                                         *
 * The Original Code is Game Network Framework (GaNeF).                    *
 *                                                                         *
 * The Initial Developers of the Original Code are                         *
 * Lars Langer and Emanuel Greisen                                         *
 * Copyright (C) 2005. Lars Langer & Emanuel Greisen                       *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * Contributor(s):                                                         *
 *   none yet....                                                          *
 *                                                                         *
 ***************************************************************************/
#ifndef FRAMEWORK_H
#define FRAMEWORK_H

#include <string>
#include <ptime.h>
#include <pinet.h>

#include "pendingacklist.h"
#include "queue.h"

template<class PacketType, class SocketType>
class PacketSender;
template<class PacketType, class SocketType>
class PacketReceiver;
template<class PacketType>
class Plugin;

/**
 * @ingroup Common
 * @brief This struct is used when throwing exceptions.
 */
struct FrameworkError
{
   const std::string msg;
   FrameworkError(const std::string &msg) : msg(msg){};
};

class FrameworkData;

/**
 * @ingroup Common
 * @brief The general interface for a framework.
 * @author Lars Langer and Emanuel Greisen
*/
template<class PacketType, class SocketType>
class Framework
{
protected:
   /// The port the framework listens on.
   int listen_port;
   /// The socket used for sending/receiving.
   SocketType socket;
   /// The receiving object, enqueues incomming packets.
   PacketReceiver<PacketType, SocketType> * receiver;
   /// All the incomming unprocessessed packets.
   Queue<PacketType> *inqueue;
   /// The queue of packets on their way out of the server.
   Queue<PacketType> *outqueue;
   /// The Sending object, takes/waits from the outqueue.
   PacketSender<PacketType, SocketType> * sender;
   /// A list of pending acknowledgements.
   PendingAckList<PacketType, SocketType> * pending_acks;

public:
   Framework(const int listen_port);
   virtual ~Framework();

protected:
   unsigned int handleAckPacket(PacketType * packet, unsigned int userid);

public:
   /// Will be called by the pendingacklist when ever we want to retransmit a packet
   virtual void retransmitPacket(PacketType * packet);
   /// This should send an AckPacket based on the packet.
   void ackPacket(PacketType * p);
   /// Called when we want to insert a pending ack into the pendingacklist.
   virtual void addPendingAck(PacketType * packet, bool haslock) = 0;
   /// This method should deliver the packet and return any buffered packets, waiting for this packet.
   virtual PacketType * deliverPacket(PacketType * p) = 0;
   /// This method should test if a packet is in order, and if not buffer the packet for later delivery.
   virtual bool isPacketReadyForDelivery(PacketType * packet) = 0;
   /// This method will be called by the sender when ever it successfully sends a reliable packet to the socket.
   virtual void sentReliablePacket(PacketType * packet) = 0;
   /// This method should add a sequence number to the pluginpacket if it does not already have one.
   virtual void addPluginSequenceNumber( PacketType * packet) = 0;

public:
   static inline unsigned int currentTimeMillis()
   {
      //struct timeval cur;
      //gettimeofday(&cur, 0);
      //return cur.tv_sec * 1000 + cur.tv_usec / 1000;
      return msecs(now());
   };

};


template<class PacketType, class SocketType>
Framework<PacketType, SocketType>::Framework( const int listen_port )
   : listen_port(listen_port),
      socket(ipaddress(0,0,0,0), listen_port)
{
   pending_acks = new PendingAckList<PacketType, SocketType>(this);
   receiver = new PacketReceiver<PacketType, SocketType>(&socket, inqueue, this);
   inqueue = new Queue<PacketType>();
   outqueue = new Queue<PacketType>();
   sender = new PacketSender<PacketType, SocketType>(&socket, outqueue, *pending_acks, this);
}


template<class PacketType, class SocketType>
Framework<PacketType, SocketType>::~Framework()
{
   delete pending_acks;
   delete receiver;
   delete inqueue;
   delete outqueue;
   delete sender;
}

template<class PacketType, class SocketType>
unsigned int Framework<PacketType, SocketType>::handleAckPacket( PacketType * packet, unsigned int userid)
{
   unsigned int obj_seq = packet->readUInt32();
   unsigned char obj_pri = packet->readUInt8();
   return pending_acks->registerAck( obj_seq, obj_pri, userid );
}

template<class PacketType, class SocketType>
void Framework<PacketType, SocketType>::retransmitPacket( PacketType * packet )
{
   outqueue->insert(packet);
}

template<class PacketType, class SocketType>
void Framework<PacketType, SocketType>::ackPacket( PacketType * p )
{
   PacketType * _p = PacketType::createAckPacket(p);
   outqueue->insert(_p);
}

#endif

---