frameworkseqnolist.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 FRAMEWORKSEQNOLIST_H
#define FRAMEWORKSEQNOLIST_H

#include <pasync.h>
USING_PTYPES
#include <map>
#include <iostream>

class FrameworkPacket;

#define SEQUENCE_CHANNELS  256+1/*The last one is for plugins*/
/**
 * @ingroup Common
 * @brief This class takes care of keeping track of ingoing/outgoing sequence numbers.
 * It contains two sequencenumbers for each priority (0-255), and two for the plugin-packets.
 * @author Lars Langer and Emanuel Greisen
*/
template<class PacketType, class SocketType>
class FrameworkSeqNoList
{
private:
   unsigned int buffered_packet_count;
   mutex next_seq_mutex;
   unsigned int ingoing_reliable_seq_numbers[SEQUENCE_CHANNELS];
   unsigned int outgoing_reliable_seq_numbers[SEQUENCE_CHANNELS];
   unsigned int ingoing_unreliable_seq_numbers[SEQUENCE_CHANNELS];
   unsigned int outgoing_unreliable_seq_numbers[SEQUENCE_CHANNELS];
   std::map<unsigned int, PacketType *> buffered_packets[SEQUENCE_CHANNELS];

private:
   void clear();

public:
   FrameworkSeqNoList();
   ~FrameworkSeqNoList();

public:
   unsigned int getNextIngoingSeqNo(PacketType * packet) const;
   bool isNext(PacketType * packet) const;
   bool isFuture(PacketType * packet) const;
   unsigned int getNextOutgoingSeqNo( PacketType * packet );
   PacketType * incrementNextIngoingSeqNo(PacketType * packet);
   void bufferPacket(PacketType * packet);
   inline unsigned int bufferePacketsTotal() const { return buffered_packet_count; };
   static int getChannel(const PacketType * packet);

};



template<class PacketType, class SocketType>
FrameworkSeqNoList<PacketType, SocketType>::FrameworkSeqNoList() : buffered_packet_count(0)
{
   clear();
}


template<class PacketType, class SocketType>
FrameworkSeqNoList<PacketType, SocketType>::~FrameworkSeqNoList()
{
}

template<class PacketType, class SocketType>
void FrameworkSeqNoList<PacketType, SocketType>::clear( )
{
   for(int i = 0; i < SEQUENCE_CHANNELS; i++)
   {
      // Reliable part
      ingoing_reliable_seq_numbers[i] = 0x100;
      outgoing_reliable_seq_numbers[i] = 0x100;
      buffered_packets[i].clear();

      // Unreliable part
      ingoing_unreliable_seq_numbers[i] = 0x100;
      outgoing_unreliable_seq_numbers[i] = 0x100;
   }
}

template<class PacketType, class SocketType>
unsigned int FrameworkSeqNoList<PacketType, SocketType>::getNextOutgoingSeqNo( PacketType * packet )
{
   int channel = getChannel(packet);
   int next_seq;
   next_seq_mutex.enter();
   if(packet->isReliable())
   {
      next_seq = outgoing_reliable_seq_numbers[channel]++;
   }
   else
   {
      next_seq = outgoing_unreliable_seq_numbers[channel]++;
   }
   next_seq_mutex.leave();
   return next_seq;
}

template<class PacketType, class SocketType>
unsigned int FrameworkSeqNoList<PacketType, SocketType>::getNextIngoingSeqNo( PacketType * packet ) const
{
   int channel = getChannel(packet);
   //std::cout << "Channel:"<<(int)channel<<": Seq: "<<ingoing_reliable_seq_numbers[channel]<<" ? "<<packet->getSequenceNumber()<<std::endl;

   return packet->isReliable() ? ingoing_reliable_seq_numbers[channel] : ingoing_unreliable_seq_numbers[channel];
}


template<class PacketType, class SocketType>
PacketType * FrameworkSeqNoList<PacketType, SocketType>::incrementNextIngoingSeqNo( PacketType * packet )
{
   int channel = getChannel(packet);
   PacketType * next_packet = 0;

   if(packet->isReliable())
   {
      ingoing_reliable_seq_numbers[channel] = packet->getSequenceNumber() + 1;

      if(buffered_packets[channel].find(ingoing_reliable_seq_numbers[channel]) != buffered_packets[channel].end())
      {
         next_packet = buffered_packets[channel][ingoing_reliable_seq_numbers[channel]];
         buffered_packets[channel].erase(ingoing_reliable_seq_numbers[channel]);
         buffered_packet_count--;
      }
   }
   else
   {
      ingoing_unreliable_seq_numbers[channel] = packet->getSequenceNumber() + 1;
   }
   return next_packet;
}

template<class PacketType, class SocketType>
void FrameworkSeqNoList<PacketType, SocketType>::bufferPacket( PacketType * packet )
{
   int channel = getChannel(packet);

   //std::cout << "BufferPacket: " << *packet << std::endl;
   //std::cout << "ingoing_reliable_seq_numbers[channel]:" << ingoing_reliable_seq_numbers[channel] << std::endl;
   if(buffered_packets[channel].find(packet->getSequenceNumber()) != buffered_packets[channel].end())
   {
      // Duplicate future packet
      //std::cout << "Discard buffering of duplicate reliable packet" << std::endl;
      delete packet;
   }
   else
   {
      buffered_packets[channel].insert(std::make_pair(packet->getSequenceNumber(),packet));
      buffered_packet_count++;
   }
}

template<class PacketType, class SocketType>
bool FrameworkSeqNoList<PacketType, SocketType>::isNext( PacketType * packet ) const
{
   //std::cout << "isNext(seq:";
   //std::cout << getNextIngoingSeqNo(packet) <<" == "<<packet->getSequenceNumber()<<std::endl;
   return getNextIngoingSeqNo(packet) == packet->getSequenceNumber();
}

template<class PacketType, class SocketType>
bool FrameworkSeqNoList<PacketType, SocketType>::isFuture( PacketType * packet ) const
{
   //std::cout << "isFuture(seq:";
   //std::cout << getNextIngoingSeqNo(packet) <<" == "<<packet->getSequenceNumber()<<std::endl;
   return getNextIngoingSeqNo(packet) < packet->getSequenceNumber();
}


template<class PacketType, class SocketType>
int FrameworkSeqNoList<PacketType, SocketType>::getChannel( const PacketType * packet )
{
   return packet->isPluginPacket() ? 256 : (int)packet->getPriority();
}



#endif

---