C:/knet/include/kNet/NetworkMessage.h

Go to the documentation of this file.

/* Copyright 2010 Jukka Jylänki

   Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */
#pragma once

#include "LockFreePoolAllocator.h"
#include "FragmentedTransferManager.h"

namespace kNet
{

typedef unsigned long packet_id_t;

inline bool PacketIDIsNewerThan(packet_id_t newID, packet_id_t oldID)
{
   if (newID > oldID)
      return true;
   if (oldID - newID >= (1 << 21))
      return true;
   return false;
}

inline packet_id_t AddPacketID(packet_id_t id, int increment)
{
   return (id + increment) & ((1 << 22) - 1);
}

inline packet_id_t SubPacketID(packet_id_t id, int sub)
{
   if ((int)id >= sub)
      return (packet_id_t)(id - sub);
   else
      return (packet_id_t)((1 << 22) - (sub-id));
}

class NetworkMessage : public PoolAllocatable<NetworkMessage>
{
public:
   NetworkMessage();

   NetworkMessage &operator=(const NetworkMessage &rhs);
   NetworkMessage(const NetworkMessage &rhs);

   ~NetworkMessage();

   char *data;

   size_t Capacity() const { return dataCapacity; }

   size_t Size() const { return dataSize; }

   void Resize(size_t newBytes, bool discard = true);

   unsigned long priority;

   packet_id_t id;

   unsigned long contentID;

   bool reliable;

   bool inOrder;

   bool obsolete;

   bool IsNewerThan(const NetworkMessage &rhs) const { return (unsigned long)(messageNumber - rhs.messageNumber) < 0x80000000; }

   static const unsigned long cPriorityDontSend = 0xFFFFFFFF;
   static const unsigned long cMaxPriority = 0xFFFFFFFE;

   int GetTotalDatagramPackedSize() const;

   unsigned long MessageNumber() const { return messageNumber; }

private:
   friend class MessageConnection;
   friend class UDPMessageConnection;
   friend class TCPMessageConnection;
   friend class FragmentedSendManager;
   friend struct FragmentedSendManager::FragmentedTransfer;

   unsigned long messageNumber;

   unsigned long reliableMessageNumber;

   unsigned long sendCount;

   unsigned long fragmentIndex;

   size_t dataCapacity;

   size_t dataSize;

   FragmentedSendManager::FragmentedTransfer *transfer;
};

} // ~kNet