TmplBlockBuffer.tlh 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266
  1. //
  2. #pragma once
  3. #include <memory>
  4. ////////////////////////////////////////////////////////////////////////////////
  5. // TmplBuffer - 定义一个连续的内存块
  6. //
  7. // Copyright (c) 1997-2019 E-COM Technology Ltd.
  8. //
  9. // V1.0 ?? - Initial Version
  10. // V2.0 2019-10-31 - Use std::shared_ptr & std::unique_ptr
  11. // V2.1 2019-11-08 - Define TmplBuffer_Base as the base class
  12. namespace ECOM
  13. {
  14. namespace Utility
  15. {
  16. //-----------------------------------------------------------------------------
  17. // TmplBuffer_Base
  18. // 基本类
  19. //-----------------------------------------------------------------------------
  20. template <typename T, typename PTR>
  21. class TmplBuffer_Base
  22. {
  23. protected:
  24. int m_nCount; // count of data, 注意是 数量 而不是 字节 长度 !!!
  25. PTR m_Data;
  26. public:
  27. TmplBuffer_Base ()
  28. {
  29. m_nCount = 0;
  30. }
  31. TmplBuffer_Base (TmplBuffer_Base && from)
  32. {
  33. m_Data = std::move (from.m_Data);
  34. m_nCount = from.m_nCount;
  35. from.m_nCount = 0;
  36. }
  37. void Attach (T * object, int count)
  38. {
  39. m_Data.reset (object);
  40. m_nCount = count;
  41. }
  42. public:
  43. operator bool () const { return ! IsEmpty (); }
  44. operator T * () { return m_Data.get (); }
  45. operator const T * () const { return m_Data.get (); }
  46. public:
  47. // Allow usage as a pointer
  48. T * operator -> ()
  49. {
  50. return m_Data.get ();
  51. }
  52. const T * operator -> () const
  53. {
  54. return m_Data.get ();
  55. }
  56. T * As ()
  57. {
  58. return m_Data.get ();
  59. }
  60. const T * As () const
  61. {
  62. return m_Data.get ();
  63. }
  64. public:
  65. int GetCount () const
  66. {
  67. return m_nCount;
  68. }
  69. int GetNbOfBytes () const
  70. {
  71. return m_nCount * sizeof (T);
  72. }
  73. bool IsEmpty () const { return (m_Data.get () == nullptr); }
  74. public:
  75. void Release () { m_Data.reset (); m_nCount = 0; }
  76. public:
  77. TmplBuffer_Base & operator = (const TmplBuffer_Base & from) = delete;
  78. TmplBuffer_Base & operator = (TmplBuffer_Base && from) = delete;
  79. public:
  80. // MemCpy
  81. void MemCopyFrom (const T * from, int count);
  82. void MemCopyTo (T * to, int count) const;
  83. protected:
  84. T * _GetBufferSetCount (int count);
  85. void MoveAssign (TmplBuffer_Base & from)
  86. {
  87. m_Data = std::move (from.m_Data);
  88. m_nCount = from.m_nCount;
  89. from.m_nCount = 0;
  90. }
  91. // make a real copy
  92. void MemCopyTo (TmplBuffer_Base & To) const;
  93. void ResizeTo (int count, TmplBuffer_Base & To) const;
  94. };
  95. //-----------------------------------------------------------------------------
  96. // TmplSharedBuffer
  97. //
  98. // 定义一个连续的内存块, 用 shared_ptr 定义, 因此可以在多个模块之间共享
  99. //-----------------------------------------------------------------------------
  100. template <typename T>
  101. class TmplSharedBuffer : public TmplBuffer_Base <T, std::shared_ptr <T>>
  102. {
  103. typedef TmplBuffer_Base <T, std::shared_ptr <T>> inherited;
  104. public:
  105. TmplSharedBuffer ()
  106. {
  107. }
  108. #if 1
  109. explicit TmplSharedBuffer (T * from, int count)
  110. {
  111. m_Data.reset (from);
  112. m_nCount = count;
  113. }
  114. #endif
  115. TmplSharedBuffer (const TmplSharedBuffer & from)
  116. {
  117. m_Data = from.m_Data;
  118. m_nCount = from.m_nCount;
  119. }
  120. TmplSharedBuffer (TmplSharedBuffer && from) : inherited (std::move (from))
  121. {
  122. }
  123. TmplSharedBuffer & operator = (const TmplSharedBuffer & from)
  124. {
  125. m_Data = from.m_Data;
  126. m_nCount = from.m_nCount;
  127. return *this;
  128. }
  129. TmplSharedBuffer & operator = (TmplSharedBuffer && from)
  130. {
  131. MoveAssign (from);
  132. return (*this);
  133. }
  134. public:
  135. T * GetBufferSetCount (int count)
  136. {
  137. return inherited::_GetBufferSetCount (count);
  138. }
  139. // return real copy
  140. TmplSharedBuffer Clone () const
  141. {
  142. TmplSharedBuffer <T> To;
  143. inherited::MemCopyTo (To);
  144. return std::move (To);
  145. }
  146. // 调整大小, 只要前面的 count 个对象
  147. // 如果要的数量比我现有的数量 (m_nCount) 多,就重新分配,然后memcpy,但填充值由上层自行决定
  148. TmplSharedBuffer Resize (int count) const
  149. {
  150. TmplSharedBuffer <T> To;
  151. inherited::ResizeTo (count, To);
  152. return std::move (To);
  153. }
  154. };
  155. //-----------------------------------------------------------------------------
  156. // TmplUniqueBuffer
  157. // 用 unique_ptr 定义, 不能共享, 但是可以转移
  158. //-----------------------------------------------------------------------------
  159. template <typename T>
  160. class TmplUniqueBuffer : public TmplBuffer_Base <T, std::unique_ptr <T>>
  161. {
  162. typedef TmplBuffer_Base <T, std::unique_ptr <T>> inherited;
  163. public:
  164. TmplUniqueBuffer ()
  165. {
  166. m_nCount = 0;
  167. }
  168. explicit TmplUniqueBuffer (T * from, int count)
  169. {
  170. m_Data.reset (from);
  171. m_nCount = count;
  172. }
  173. TmplUniqueBuffer (TmplUniqueBuffer && from) : inherited (std::move (from))
  174. {
  175. }
  176. TmplUniqueBuffer (const TmplUniqueBuffer & from) = delete;
  177. TmplUniqueBuffer & operator = (const TmplUniqueBuffer & from) = delete;
  178. TmplUniqueBuffer & operator = (TmplUniqueBuffer && from)
  179. {
  180. MoveAssign (from);
  181. return (*this);
  182. }
  183. public:
  184. T * GetBufferSetCount (int count)
  185. {
  186. return inherited::_GetBufferSetCount (count);
  187. }
  188. // return real copy
  189. TmplUniqueBuffer Clone () const
  190. {
  191. TmplUniqueBuffer <T> To;
  192. inherited::MemCopyTo (To);
  193. return std::move (To);
  194. }
  195. public:
  196. T * Detach () { m_nCount = 0; auto pc = m_Data.release (); ASSERT (pc); return pc; }
  197. };
  198. }
  199. }
  200. // 共享版本
  201. // 为像素数据定义一个专用的类型
  202. typedef ECOM::Utility::TmplSharedBuffer <unsigned char> BlockBuffer;
  203. // 非共享版本
  204. typedef ECOM::Utility::TmplUniqueBuffer <unsigned char> UniqueBuffer;
  205. typedef UniqueBuffer IBlockBuffer;
  206. typedef UniqueBuffer OBlockBuffer;