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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
chxfgbuf.h
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：9k
源码类别：

Symbian

开发平台：

Visual C++

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