C:/knet/include/kNet/DataDeserializer.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 "kNet/Types.h"

#include "BasicSerializedDataTypes.h"
#include "SerializedDataIterator.h"

namespace kNet
{

class DataDeserializer
{
public:
   DataDeserializer(const char *data, size_t size);

   DataDeserializer(const char *data, size_t size, const SerializedMessageDesc *msgTemplate);

   void ResetTraversal();

   template<typename T>
   T Read();

   static const u32 VLEReadError = 0xFFFFFFFF;

   template<typename VLEType>
   u32 ReadVLE();

   template<typename T>
   void ReadArray(T *dst, size_t numElems);

   std::string ReadString();

   u32 ReadBits(int numBits);

   u32 GetDynamicElemCount();

   u32 BytesLeft() const { return (u32)((elemOfs >= size) ? 0 : (size - elemOfs)); }

   u32 BitsLeft() const { return (u32)((elemOfs >= size) ? 0 : ((size - elemOfs)*8 - bitOfs)); }

   u32 BytePos() const { return (u32)elemOfs; }

   u32 BitPos() const { return bitOfs; }

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

   const char *CurrentData() const { return data + BytePos(); }

   void SkipBits(size_t numBits);

   void SkipBytes(size_t numBytes) { SkipBits(numBytes * 8); }

private:
   const char *data;
   size_t size;
   size_t elemOfs;
   int bitOfs;

   Ptr(SerializedDataIterator) iter;

   u32 ReadBitsToU32(int count);

   DataDeserializer(const DataDeserializer &);
   void operator =(const DataDeserializer &);
};

template<typename T>
T DataDeserializer::Read()
{
   assert(!iter || iter->NextElementType() == SerializedDataTypeTraits<T>::type);
   T value;
   u8 *data = reinterpret_cast<u8*>(&value);

   for(int i = 0; i < sizeof(value); ++i)
      data[i] = (u8)ReadBitsToU32(8);

   if (iter)
      iter->ProceedToNextVariable();

   return value;
}

template<> std::string DataDeserializer::Read<std::string>();

template<> bool DataDeserializer::Read<bit>();

template<typename VLEType>
u32 DataDeserializer::ReadVLE()
{
   const u32 cStreamEndError = 0xFFFFFFFF;

   if (BitsLeft() < VLEType::numBits1 + 1)
      return cStreamEndError;

   u32 sml = ReadBits(VLEType::numBits1 + 1);
   if ((sml & (1 << VLEType::numBits1)) == 0)
      return sml;
   sml &= (1 << VLEType::numBits1) - 1;

   const int numBitsMed = VLEType::numBits2 + (VLEType::numBits3 == 0 ? 0 : 1);
   if (BitsLeft() < numBitsMed)
      return cStreamEndError;

   u32 med = ReadBits(numBitsMed);
   if ((med & (1 << VLEType::numBits2)) == 0)
      return sml | (med << VLEType::numBits1);

   if (BitsLeft() < VLEType::numBits3)
      return cStreamEndError;

   med &= (1 << VLEType::numBits2) - 1;
   u32 large = ReadBits(VLEType::numBits3);
   return sml | (med << VLEType::numBits1) | (large << (VLEType::numBits1 + VLEType::numBits2));
}

template<typename T>
void DataDeserializer::ReadArray(T *dst, size_t numElems)
{
   for(size_t i = 0; i < numElems; ++i)
      dst[i] = Read<T>();

   // The above will move on to the next variable in the template accordingly, but if the number
   // of elements to read is zero, it needs to be assumed that this was a dynamic block and 
   // the size was 0.
   if (numElems == 0 && iter)
      iter->ProceedToNextVariable();
}

template<>
void DataDeserializer::ReadArray(bit *dst, size_t numElems);

} // ~kNet