C:/knet/include/kNet/DataSerializer.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 <vector>
#include <cassert>
#include <string>

#include "kNet/SharedPtr.h"

#include "kNet/MessageListParser.h"
#include "kNet/SerializedDataIterator.h"
#include "kNet/VLEPacker.h"

namespace kNet
{

struct SerializedMessage : public RefCountable
{
   std::vector<char> data;
};

class DataSerializer
{
public:
   explicit DataSerializer(size_t maxBytes_ = 128 * 1024);
   
   DataSerializer(size_t maxBytes_, const SerializedMessageDesc *msgTemplate);

   DataSerializer(char *data_, size_t maxBytes_);

   DataSerializer(char *data_, size_t maxBytes_, const SerializedMessageDesc *msgTemplate);

   explicit DataSerializer(std::vector<char> &data, size_t maxBytes);

   DataSerializer(std::vector<char> &data, size_t maxBytes, const SerializedMessageDesc *msgTemplate);

   template<typename T>
   void Add(const T &value);

   template<typename VLEType>
   void AddVLE(u32 value);

   void AppendBits(u32 value, int amount);

   void AddString(const char *str);

   void AddString(const std::string &str) { AddString(str.c_str()); }

   template<typename T>
   void AddArray(const T *data, u32 count);

   void AddAlignedByteArray(const void *data, u32 numBytes);

   void SetVaryingElemSize(u32 count);

   void ResetFill();

   char *GetData() const { return data; }
   
   void SkipNumBytes(size_t numBytes);

   size_t BytesFilled() const { return elemOfs + ((bitOfs != 0) ? 1 : 0); }

   size_t BitsFilled() const { return elemOfs * 8 + bitOfs; }

   size_t Capacity() const { return maxBytes; }

   size_t ByteOffset() const { return elemOfs; }

   size_t BitOffset() const { return bitOfs; }

private:
   void AppendByte(u8 byte);
   void AppendUnalignedByte(u8 byte);
   void AppendAlignedByte(u8 byte);

   Ptr(SerializedDataIterator) iter;

   char *data;

   size_t maxBytes;

   Ptr(SerializedMessage) messageData;
   size_t elemOfs;
   int bitOfs; 
};

template<typename T>
void DataSerializer::Add(const T &value)
{
#ifdef _DEBUG
   if (iter)
   {
      BasicSerializedDataType nextExpectedType = iter->NextElementType();
      BasicSerializedDataType currentFilledType = SerializedDataTypeTraits<T>::type;
      assert(nextExpectedType == currentFilledType);
   }
#endif
   const u8 *data = reinterpret_cast<const u8*>(&value);

   for(int i = 0; i < sizeof(value); ++i)
      AppendByte(data[i]);

   if (iter)
      iter->ProceedToNextVariable();
}

template<> void DataSerializer::Add<char*>(char * const & value);
template<> void DataSerializer::Add<const char*>(const char * const & value);
template<> void DataSerializer::Add<std::string>(const std::string &value);

template<> void DataSerializer::Add<bit>(const bit &value);

template<typename VLEType>
void DataSerializer::AddVLE(u32 value)
{
   assert(!iter); // Can't use with a template.

   u32 encoded = VLEType::Encode(value);
   int numBits = VLEType::GetEncodedBitLength(value);

   if (numBits == 8) Add<u8>((u8)encoded);
   else if (numBits == 16) Add<u16>((u16)encoded);
   else if (numBits == 32) Add<u32>(encoded);
   else
   {
      assert(false && "N/I numBits count! todo.. Write AddBits()");
   }
}

template<typename T>
void DataSerializer::AddArray(const T *data, u32 count)
{
   for(u32 i = 0; i < count; ++i)
      Add<T>(data[i]); 

   // If the user added an empty array, we have to manually walk to the next variable.
   if (count == 0 && iter)
      iter->ProceedToNextVariable();
}

template<typename T> size_t SumArray(const T &data, size_t numElems)
{
   size_t size = 0;
   for(size_t i = 0; i < numElems; ++i)
      size += data[i].Size();
   return size;
}

} // ~kNet