UtBuffer.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company.
// ****************************************************************************
 
#ifndef UTBUFFER_HPP
#define UTBUFFER_HPP
 
#include <algorithm>
#include <cstring>
 
#include "WsfUtExport.hpp"

class WSF_UT_EXPORT UtBuffer
{
public:
   UtBuffer(int aBytes)
      : mBuffer(nullptr)
      , mCanGrow(false)
   {
      SetBigEndian();
      SetBuffer(new char[aBytes], aBytes, true);
   }

   UtBuffer(char* aData, int aBytes, bool aCanGrow = false)
      : mBuffer(nullptr)
      , mCanGrow(false)
   {
      SetBigEndian();
      SetBuffer(aData, aBytes, aCanGrow);
   }
 
   static const int cDEFAULT_BUFFER_SIZE = 1024;

   UtBuffer(const UtBuffer& aSrc)
      : mBuffer(new char[aSrc.mBytes])
      , mBytes(aSrc.mBytes)
      , mGetPos(aSrc.mGetPos)
      , mPutPos()
      , mCanGrow(true)
      , mSwapBytes(aSrc.mSwapBytes)
   {
      if (aSrc.mPutPos > mGetPos)
      {
         PutRaw(aSrc.mBuffer, aSrc.mPutPos);
      }
   }

   UtBuffer()
      : mBuffer(nullptr)
      , mCanGrow(false)
   {
      SetBigEndian();
      SetBuffer(new char[cDEFAULT_BUFFER_SIZE], cDEFAULT_BUFFER_SIZE);
      mCanGrow = true;
   }
 
   UtBuffer& operator=(const UtBuffer&) = delete;
 
   ~UtBuffer() { Dispose(); }

   void EnableByteSwap(bool aSwapBytes) { mSwapBytes = aSwapBytes; }
   void SetBigEndian();
   void SetLittleEndian();
   void SetNativeByteOrder();
 
   void Dispose()
   {
      if (mCanGrow)
      {
         delete[] mBuffer;
      }
      mBuffer = nullptr;
   }

   void SetBuffer(char* aData, size_t aBytes, bool aCanGrow = false)
   {
      Dispose();
      mBuffer  = aData;
      mBytes   = aBytes;
      mPutPos  = 0;
      mGetPos  = 0;
      mCanGrow = aCanGrow;
   }

   void SetPutPos(size_t aPos) { mPutPos = aPos; }
   size_t& GetPutPos() { return mPutPos; }
   size_t GetPutPos() const { return mPutPos; }
   void SetGetPos(size_t aPos) { mGetPos = aPos; }
   size_t& GetGetPos() { return mGetPos; }
   size_t GetGetPos() const { return mGetPos; }

   char* GetBuffer() { return mBuffer; }
   const char* GetBuffer() const { return mBuffer; }

   size_t GetBytes() const { return mBytes; }

   void PutRaw(const char* aBuffer, size_t aBytes)
   {
      CheckPutSpace(aBytes);
      memcpy(mBuffer + mPutPos, aBuffer, aBytes);
      mPutPos += aBytes;
   }

   void GetRaw(char* aBuffer, size_t aBytes)
   {
      memcpy(aBuffer, mBuffer + mGetPos, aBytes);
      mGetPos += aBytes;
   }

   void Reset() { mGetPos = mPutPos = 0; }
 
   void Move(size_t aBeginOffset, size_t aEndOffset, size_t aNewBegin);

   void Grow(size_t aNewSize)
   {
      if (aNewSize >= mBytes)
      {
         GrowBy(aNewSize - mBytes);
      }
   }

   void GrowBy(size_t aBytes);
   size_t GetValidBytes() const { return mPutPos - mGetPos; }
   void SwapBuffer(UtBuffer& aRhs)
   {
      std::swap(mBuffer, aRhs.mBuffer);
      std::swap(mBytes, aRhs.mBytes);
      std::swap(mGetPos, aRhs.mGetPos);
      std::swap(mPutPos, aRhs.mPutPos);
      std::swap(mCanGrow, aRhs.mCanGrow);
   }
 
   void* ReleaseBuffer()
   {
      void* bufferPtr = mBuffer;
      mBuffer         = nullptr;
      mBytes          = 0;
      return bufferPtr;
   }

   template<typename T>
   void Put(const T& aVal)
   {
      PutP<sizeof(T)>(reinterpret_cast<const char*>(&aVal));
   }

   template<typename T>
   void Get(T& aVal)
   {
      GetP<sizeof(T)>(reinterpret_cast<char*>(&aVal));
   }
 
   bool CheckPutSpace(size_t aPutSize)
   {
      bool needsToGrow = (aPutSize + mPutPos >= mBytes);
      if (mCanGrow & needsToGrow)
      {
         GrowBy(aPutSize);
      }
      return needsToGrow & !mCanGrow;
   }
 
protected:
   template<int BYTES>
   void PutP(const char* aBuffer)
   {
      CheckPutSpace(BYTES);
      if (mSwapBytes)
      {
         for (size_t i = 0; i < BYTES; ++i)
         {
            *(mBuffer + mPutPos + i) = aBuffer[BYTES - 1 - i];
         }
      }
      else
      {
         memcpy(mBuffer + mPutPos, aBuffer, BYTES);
      }
      mPutPos += BYTES;
   }
 
   template<int BYTES>
   void GetP(char* aBuffer)
   {
      if (mSwapBytes)
      {
         char* bufPtr = mBuffer + mGetPos;
         for (size_t i = 0; i < BYTES; ++i)
         {
            *(aBuffer + i) = bufPtr[BYTES - 1 - i];
         }
      }
      else
      {
         memcpy(aBuffer, mBuffer + mGetPos, BYTES);
      }
      mGetPos += BYTES;
   }
 
   char*  mBuffer;
   size_t mBytes;
   size_t mGetPos;
   size_t mPutPos;
   bool   mCanGrow;
   bool   mSwapBytes;
};
 
#endif