BVB Source Codes

CRYENGINE Show XMLCPB_BufferWriter.h Source code

Return Download CRYENGINE: download XMLCPB_BufferWriter.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4. *************************************************************************/
  5.  
  6. #pragma once
  7. #ifndef XMLCPB_BUFFERWRITER_H
  8.         #define XMLCPB_BUFFERWRITER_H
  9.  
  10.         #include "../XMLCPB_Common.h"
  11.         #include <CryCore/Platform/IPlatformOS.h>
  12.         #include <CryCore/StlUtils.h>
  13.  
  14. namespace XMLCPB {
  15.  
  16. class CWriter;
  17.  
  18. class CBufferWriter
  19. {
  20. public:
  21.         struct SAddr
  22.         {
  23.                 uint16 bufferOffset;
  24.                 uint16 bufferIndex;
  25.  
  26.                 SAddr() { Reset(); }
  27.  
  28.                 void Reset()
  29.                 {
  30.                         bufferOffset = 0xffff;
  31.                         bufferIndex = 0xffff;
  32.                 }
  33.  
  34.                 bool IsValid() const
  35.                 {
  36.                         return bufferOffset != 0xffff || bufferIndex != 0xffff;
  37.                 }
  38.         };
  39.  
  40. public:
  41.  
  42.         CBufferWriter(int bufferSize);
  43.         void         Init(CWriter* pWriter, bool useStreaming);
  44.  
  45.         void         AddData(const void* pSource, int sizeToAdd);
  46.         template<class T>
  47.         void         AddDataEndianAware(T val);
  48.         void         AddDataNoSplit(SAddr& addr, const void* pSource, int sizeToAdd);
  49.         void         GetCurrentAddr(SAddr& addr) const;
  50.         uint32       GetUsedMemory() const;
  51.         FlatAddr     ConvertSegmentedAddrToFlatAddr(const SAddr& addr);
  52.         void         WriteToFile();
  53.         void         WriteToMemory(uint8*& rpData, uint32& outWriteLoc);
  54.         uint32       GetDataSize() const;
  55.  
  56.         ILINE uint8* GetPointerFromAddr(const SAddr& addr) const
  57.         {
  58.                 assert(!m_usingStreaming);
  59.                 //if (m_usingStreaming)
  60.                 //      return NULL;
  61.  
  62.                 assert(addr.bufferIndex < m_buffers.size());
  63.                 return m_buffers[addr.bufferIndex]->GetPointer(addr.bufferOffset);
  64.         }
  65.  
  66. private:
  67.  
  68.         void AddBuffer();
  69.  
  70.         struct SSimpleBuffer : public _reference_target_t
  71.         {
  72.         public:
  73.                 SSimpleBuffer(int size)
  74.                         : m_pBuffer(NULL)
  75.                         , m_size(size)
  76.                         , m_used(0)
  77.                 {
  78.                         m_pBuffer = new uint8[size];
  79.                 }
  80.  
  81.                 ~SSimpleBuffer()
  82.                 {
  83.                         FreeBuffer();
  84.                 }
  85.  
  86.                 bool   CanAddData(int sizeToAdd) const { return m_used + sizeToAdd <= m_size; }
  87.                 bool   IsFull() const                  { return m_used == m_size; }
  88.                 void   AddData(const uint8* pSource, int sizeToAdd);
  89.                 int    GetFreeSpaceSize() const        { return m_size - m_used; }
  90.                 uint32 GetUsed() const                 { return m_used; }
  91.                 uint8* GetPointer(uint32 offset) const { assert(offset < m_used); return GetBasePointer() + offset; }
  92.                 void   WriteToFile(CWriter& Writer);
  93.                 void   WriteToMemory(CWriter& Writer, uint8*& rpData, uint32& outWriteLoc);
  94.                 uint32 GetDataSize() const    { return m_used; }
  95.                 uint8* GetBasePointer() const { return m_pBuffer; }
  96.                 void   FreeBuffer()           { SAFE_DELETE_ARRAY(m_pBuffer); }
  97.  
  98.         private:
  99.                 uint8* m_pBuffer;
  100.                 uint32 m_used;
  101.                 uint32 m_size;
  102.         };
  103.  
  104. private:
  105.         typedef _smart_ptr<SSimpleBuffer> SSimpleBufferT;
  106.         std::vector<SSimpleBufferT> m_buffers;
  107.         CWriter*                    m_pWriter;
  108.         int                         m_bufferSize;
  109.         bool                        m_usingStreaming;
  110. };
  111.  
  112. template<class T>
  113. inline void CBufferWriter::AddDataEndianAware(T val)
  114. {
  115.         SwapIntegerValue(val);
  116.         AddData(&val, sizeof(val));
  117. }
  118.  
  119. inline void CBufferWriter::SSimpleBuffer::AddData(const uint8* pSource, int sizeToAdd)
  120. {
  121.         assert(CanAddData(sizeToAdd));
  122.  
  123.         memcpy(GetBasePointer() + m_used, pSource, sizeToAdd);
  124.  
  125.         m_used += sizeToAdd;
  126. }
  127.  
  128. class AttrStringAllocatorImpl
  129. {
  130.         static const int k_numPerBucket = 4096;
  131.         static const int k_maxItems = 1024 * 1024;
  132.         static uint64*   s_buckets[k_maxItems / k_numPerBucket];
  133.         static uint64*   s_ptr;
  134.         static uint64*   s_end;
  135.         static int       s_currentBucket;
  136.         static int       s_poolInUse;
  137. public:
  138.         static void LockPool()
  139.         {
  140.         #ifndef _RELEASE
  141.                 if (gEnv->mMainThreadId != CryGetCurrentThreadId())
  142.                         __debugbreak();
  143.         #endif
  144.                 s_poolInUse++;
  145.         }
  146.         static void* AttrStringAlloc()
  147.         {
  148.         #ifndef _RELEASE
  149.                 if (gEnv->mMainThreadId != CryGetCurrentThreadId())
  150.                         __debugbreak();
  151.         #endif
  152.                 uint64* ptr = s_ptr;
  153.                 if (ptr)
  154.                 {
  155.                         s_ptr++;
  156.                         if (s_ptr == s_end)
  157.                         {
  158.                                 s_ptr = NULL;
  159.                         }
  160.                 }
  161.                 else
  162.                 {
  163.         #ifndef _RELEASE
  164.                         if (s_currentBucket == CRY_ARRAY_COUNT(s_buckets))
  165.                                 __debugbreak();
  166.         #endif
  167.                         ptr = (uint64*)malloc(k_numPerBucket * sizeof(uint64));
  168.                         assert(s_currentBucket >= 0 && s_currentBucket < CRY_ARRAY_COUNT(s_buckets));
  169.                         s_buckets[s_currentBucket++] = ptr;
  170.                         s_ptr = ptr + 1;
  171.                         s_end = ptr + k_numPerBucket;
  172.                 }
  173.                 return ptr;
  174.         }
  175.         static void CleanPool()
  176.         {
  177.         #ifndef _RELEASE
  178.                 if (gEnv->mMainThreadId != CryGetCurrentThreadId())
  179.                         __debugbreak();
  180.         #endif
  181.                 s_poolInUse--;
  182.                 if (!s_poolInUse)
  183.                 {
  184.                         for (int i = 0; i < s_currentBucket; i++)
  185.                         {
  186.                                 free(s_buckets[i]);
  187.                         }
  188.                         s_currentBucket = 0;
  189.                         s_ptr = NULL;
  190.                 }
  191.         }
  192. };
  193.  
  194. template<class T>
  195. class AttrStringAllocator : public stl::SAllocatorConstruct
  196. {
  197. public:
  198.         typedef size_t    size_type;
  199.         typedef ptrdiff_t difference_type;
  200.         typedef T*        pointer;
  201.         typedef const T*  const_pointer;
  202.         typedef T&        reference;
  203.         typedef const T&  const_reference;
  204.         typedef T         value_type;
  205.  
  206.         template<class U> struct rebind
  207.         {
  208.                 typedef AttrStringAllocator<U> other;
  209.         };
  210.  
  211.         AttrStringAllocator() throw()
  212.         {
  213.         }
  214.  
  215.         AttrStringAllocator(const AttrStringAllocator&) throw()
  216.         {
  217.         }
  218.  
  219.         template<class U> AttrStringAllocator(const AttrStringAllocator<U> ) throw()
  220.         {
  221.         }
  222.  
  223.         ~AttrStringAllocator() throw()
  224.         {
  225.         }
  226.  
  227.         pointer address(reference x) const
  228.         {
  229.                 return &x;
  230.         }
  231.  
  232.         const_pointer address(const_reference x) const
  233.         {
  234.                 return &x;
  235.         }
  236.  
  237.         pointer allocate(size_type n = 1, const void* hint = 0)
  238.         {
  239.                 if (sizeof(T) == 8 && n == 1)
  240.                 {
  241.                         return (T*)AttrStringAllocatorImpl::AttrStringAlloc();
  242.                 }
  243.                 else
  244.                 {
  245.                         return (T*)malloc(n * sizeof(T));
  246.                 }
  247.         }
  248.  
  249.         void deallocate(pointer p, size_type n = 1)
  250.         {
  251.                 if (sizeof(T) != 8 || n != 1)
  252.                 {
  253.                         free(p);
  254.                 }
  255.         }
  256.  
  257.         size_type max_size() const throw()
  258.         {
  259.                 return INT_MAX;
  260.         }
  261.  
  262.         void destroy(pointer p)
  263.         {
  264.                 p->~T();
  265.         }
  266.  
  267.         pointer new_pointer()
  268.         {
  269.                 return new(allocate())T();
  270.         }
  271.  
  272.         pointer new_pointer(const T& val)
  273.         {
  274.                 return new(allocate())T(val);
  275.         }
  276.  
  277.         void delete_pointer(pointer p)
  278.         {
  279.                 p->~T();
  280.                 deallocate(p);
  281.         }
  282.  
  283.         bool operator==(const AttrStringAllocator&) { return true; }
  284.         bool operator!=(const AttrStringAllocator&) { return false; }
  285. };
  286.  
  287. }  // end namespace
  288.  
  289. #endif
  290.  
downloadXMLCPB_BufferWriter.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top