开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
chxfgbuf.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：8k
源码类别：

Symbian

开发平台：

C/C++

chxfgbuf.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifndef _HXFGBUF_H_
  37. #define _HXFGBUF_H_
  39. /*
  40.  * IHXFragmentedBuffer
  41.  *     STDMETHOD(GetEnumerator)(REF(IEnumHXFragmentedBuffer *));
  42.  *     STDMETHOD(Prepend)(IHXBuffer *pBufferFrom, UINT32 ulStartFrom, UINT32 ulLengthFrom);
  43.  *     STDMETHOD(Append)(IHXBuffer *pBufferFrom, UINT32 ulStartFrom, UINT32 ulLengthFrom);
  44.  *     STDMETHOD(Insert)(IHXBuffer *pBufferFrom, UINT32 ulStartFrom, UINT32 ulLengthFrom, UINT32 ulStartTo);
  45.  *     STDMETHOD(Replace)(IHXBuffer *pBufferFrom, UINT32 ulStartFrom, UINT32 ulLengthFrom, UINT32 ulStartTo);
  46.  *     STDMETHOD(Get)(UINT32 ulStartFrom, UINT32 ulLengthFrom, REF(UCHAR*) pData, REF(UINT32) ulLength);
  47.  *     STDMETHOD_(UCHAR*, GetBuffer)(UINT32 ulStartFrom, UINT32 ulLengthFrom);
  48.  *
  49.  * IEnumHXFragmentedBuffer
  50.  *     STDMETHOD(Reset)();
  51.  *     STDMETHOD(Next)(UINT32 ulRequested, IHXBuffer *[]arrpbufReturned, REF(UINT32) ulReturned);
  52.  *     STDMETHOD(Skip)(UINT32 ulNumToSkip);
  53.  *     STDMETHOD(Clone)(REF(IEnumHXFragmentedBuffer *)ppefbufClone);
  54.  */
  56. #include "hxtypes.h"
  57. #include "unkimp.h"
  58. #include "ihxfgbuf.h"
  59. #include "hxbuffer.h"
  60. #include "arrenum.h"
  62. DECLARE_INTERFACE_ARRAY_ENUMERATOR(IHXBuffer, IHXEnumFragmentedBuffer);
  65.     /*
  66.      * This class is to allow fragment(s) to be
  67.      * inserted into the middle of existing buffers
  68.      * without re-copying the bytes.
  69.      *
  70.      * Before:
  71.      *     ...
  72.      *     IHXBuffer[100]
  73.      *     ...
  74.      *
  75.      * After:
  76.      *     ...
  77.      *     (_CBufferFragment(0,20))IHXBuffer[20]----
  78.      *     (New)IHXBuffer[43]        -->IHXBuffer[100]
  79.      *     (_CBufferFragment(21,80)IHXBuffer[80]----/
  80.      *     ...
  81.      *
  82.      * XXX Optimize by overriding the new operator.
  83.      *
  84.      * The local implementation should maintain a 
  85.      * static array of BufferFragment arrays 
  86.      * (BufferFragment[n][32]), and return the next 
  87.      * free one.
  88.      * When all BFs are in use, the first dimension
  89.      * should be re-alloced to twice it's size
  90.      * (BufferFragment*[n*2]). The existing pointers 
  91.      * are then copied into it.  A new block
  92.      * of memory to cover the second dimension of 
  93.      * each of the new locations in the first dimension
  94.      * is alloced, (BufferFragment[n*32])
  95.      * then its contents are distrubuted to the first 
  96.      * array.
  97.      * 
  98.      * This has several benefits: 
  99.      * - not copying the data around when growing.
  100.      * - Balancing allocs with wasted space.
  101.      * - Not allocing for every new object.
  102.      * - Fixed second dimension keeps management simple.
  103.      */
  104. class _CBufferFragment
  105.     : public IHXBuffer
  106.     , public CUnknownIMP
  107. {
  108.     DECLARE_UNKNOWN(_CBufferFragment)
  109. public:
  110.     _CBufferFragment()
  111. : m_pData(NULL)
  112. , m_ulStart(0)
  113. , m_ulLength(0)
  114.     {}
  115.     ~_CBufferFragment()
  116.     {HX_RELEASE(m_pData); m_ulStart=0; m_ulLength=0;}
  118.     _CBufferFragment* _SetBuffer(IHXBuffer* pData, UINT32 ulStart, UINT32 ulLength);
  119.     STDMETHOD(Set)(const UCHAR* pData, UINT32 ulLength);
  120.     STDMETHOD(Get)(REF(UCHAR*) pData, REF(UINT32) ulLength);
  121.     STDMETHOD(SetSize)(UINT32 ulLength);
  122.     STDMETHOD_(UINT32, GetSize)();
  123.     STDMETHOD_(UCHAR*, GetBuffer)();
  125. private:
  126.     IHXBuffer* m_pData;
  127.     UINT32 m_ulStart, m_ulLength;
  128. };
  130. class CHXFragmentedBuffer
  131.     : public IHXFragmentedBuffer
  132.     , public IHXBuffer
  133.     , public CUnknownIMP
  134. {
  136.     DECLARE_UNKNOWN(CHXFragmentedBuffer)
  138. private:
  140.     class _CFragment;
  141.     class _CFragmentList;
  142.     friend class _CFragment;
  143.     friend class _CFragmentList;
  145.     /* This class implements the listnodes of fragments
  146.      */
  147.     class _CFragment
  148.     {
  149.     public:
  150. inline _CFragment* Prev(){return m_pPrev;}
  151. inline _CFragment* Next(){return m_pNext;}
  153. _CFragment* SetData(IHXBuffer* pData);
  154. _CFragment* SetData(IHXBuffer* pData, UINT32 ulStartFrom, UINT32 ulLengthFrom);
  156. inline IHXBuffer* GetData(){return m_pData;}
  158. _CFragment* Insert(_CFragment* pNewPrev);
  159. _CFragment* Append(_CFragment* pNewNext);
  160. _CFragment* Remove();
  162. _CFragment():m_pData(NULL),m_pPrev(NULL),m_pNext(NULL){}
  163. ~_CFragment()
  164. {
  165.     HX_RELEASE(m_pData); 
  166.     if(m_pNext)
  167.     {
  168. m_pNext->_SetPrev(m_pPrev);
  169.     }
  170.     if(m_pPrev)
  171.     {
  172. m_pPrev->_SetNext(m_pNext);
  173.     }
  174. }
  175.     private:
  176. inline void _SetPrev(_CFragment* pfrgNew){m_pPrev = pfrgNew;}
  177. inline void _SetNext(_CFragment* pfrgNew){m_pNext = pfrgNew;}
  179. IHXBuffer* m_pData;
  180. _CFragment* m_pPrev;
  181. _CFragment* m_pNext;
  182.     };
  184.     /* This class maintains the First and Last pointers
  185.      * for a list of fragments
  186.      */
  187.     class _CFragmentList
  188.     {
  189.     public:
  190. _CFragmentList()
  191.     : m_pfrgListStart(NULL)
  192.     , m_pfrgListEnd(NULL)
  193.     , m_ulTotal(0)
  194. {}
  195. ~_CFragmentList()
  196. {
  197.     m_pfrgListEnd = NULL; 
  198.     while(m_pfrgListStart)
  199.     {
  200. m_pfrgListStart=m_pfrgListStart->Remove();
  201.     }
  202. }
  204. inline _CFragment* First(){return m_pfrgListStart;}
  205. inline _CFragment* Last(){return m_pfrgListEnd;}
  207. void Remove(_CFragment* pfrgObsolete);
  208. void Insert(_CFragment* pfrgNew, _CFragment* pfrgRelative = NULL);
  209. void Append(_CFragment* pfrgNew, _CFragment* pfrgRelative = NULL);
  211. inline UINT32 GetTotal(){return m_ulTotal;}
  213.     private:
  214. _CFragment* m_pfrgListStart;
  215. _CFragment* m_pfrgListEnd;
  216. UINT32      m_ulTotal;
  217.     };
  219. public:
  220.     CHXFragmentedBuffer()
  221.     {}
  222.     ~CHXFragmentedBuffer(){}
  224.     /* IHXFragmentedBuffer Methods
  225.      */
  226.     STDMETHOD(GetEnumerator)
  227.     (
  228. THIS_ 
  229. IHXEnumFragmentedBuffer** ppefbNewEnum
  230.     );
  232.     STDMETHOD(Prepend)
  233.     (
  234. THIS_ 
  235. IHXBuffer* pBufferFrom, 
  236. ULONG32 ulStartFrom, 
  237. ULONG32 ulLengthFrom
  238.     );
  239.     STDMETHOD(Append)
  240.     (
  241. THIS_ 
  242. IHXBuffer* pBufferFrom, 
  243. ULONG32 ulStartFrom, 
  244. ULONG32 ulLengthFrom
  245.     );
  246.     STDMETHOD(Insert)
  247.     (
  248. THIS_ 
  249. IHXBuffer* pBufferFrom, 
  250. ULONG32 ulStartFrom, 
  251. ULONG32 ulLengthFrom, 
  252. ULONG32 ulStartTo
  253.     );
  254.     STDMETHOD(Replace)
  255.     (
  256. THIS_ 
  257. IHXBuffer* pBufferFrom, 
  258. ULONG32 ulStartFrom, 
  259. ULONG32 ulLengthFrom, 
  260. ULONG32 ulStartTo
  261.     );
  263.     STDMETHOD(Get)
  264.     (
  265. THIS_ 
  266. ULONG32 ulStartFrom, 
  267. ULONG32 ulLengthFrom, 
  268. REF(UCHAR*) pData, 
  269. REF(ULONG32) ulLength
  270.     );
  271.     STDMETHOD_(UCHAR*, GetBuffer)
  272.     (
  273. THIS_ 
  274. ULONG32 ulStartFrom, 
  275. ULONG32 ulLengthFrom
  276.     );
  279.     /* IHXBuffer Methods
  280.      */ 
  281.     STDMETHOD(Set)(const UCHAR* pData, ULONG32 ulLength);
  282.     STDMETHOD(Get)(REF(UCHAR*) pData, REF(ULONG32) ulLength);
  283.     STDMETHOD(SetSize)(ULONG32 ulLength);
  284.     STDMETHOD_(ULONG32, GetSize)();
  285.     STDMETHOD_(UCHAR*, GetBuffer)();
  287. private:
  288.     STDMETHOD(_FindFragment)(UINT32 ulFindIndex, REF(_CFragment*) pfrgCurrent, REF(UINT32) ulCurrentSize, REF(UINT32) ulCurrentStart);
  289.     void _RecursiveBufferCopy
  290.     (
  291. UCHAR* pucDestBuffer,
  292. IHXBuffer* pbufSource,
  293. UINT32 ulStartIndex,
  294. UINT32 ulSize
  295.     );
  297.     _CFragmentList m_frglstThis;
  298. };
  300. #endif //!_HXFGBUF_H_