hxinfcod.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:11k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. #ifndef _HXINFCOD_H_
  36. #define _HXINFCOD_H_
  37. #include "hxtypes.h"
  38. #include "hxstring.h"
  39. #include "timerep.h"
  40. #include "ihxostrm.h"
  41. #include "unkimp.h"
  42. #define Perplex_BASE  41
  43. #define Perplex_PER_ULONG32 6
  44. #define Perplex_ALIGNMENT 4
  45. // for dynamic buffer used in Encoder/Decoder classes.
  46. #define DEFAULT_GROW_SIZE 1024
  47. class CHXInfoEncoder;
  48. class CHXInfoDecoder;
  49. class CHXSimpleBuffer; // crappy little buffer class used by CHXInfoEncoder
  50. /////////////////////////////////////////////////////////////////////
  51. // A simple buffer. There is no implicit access/bounds checking,
  52. // you have to do that yourself or use the 'Safexxxxx()' methods.
  53. // It's actual size is usually not what you set with resizeBuffer(),
  54. // since the size will be rounded up to the nearest 'GrowBy' size.
  55. class CHXSimpleBuffer
  56. {
  57. public:
  58. CHXSimpleBuffer();
  59. CHXSimpleBuffer(UINT32 nSize, UINT32 nGrowBy=DEFAULT_GROW_SIZE);
  60. ~CHXSimpleBuffer();
  61. inline UCHAR* GetPtr()    const { return(m_pData); }
  62. inline UCHAR* GetPtrAt(UINT32 nOffset)  const { return(m_pData+nOffset); }
  63. inline UCHAR GetDataAt(UINT32 nOffset) const { return(*(m_pData+nOffset)); }
  64. inline UINT32 GetSize()    const { return(m_nSize); }
  65. inline void SetUCHAR(UINT32 off, UCHAR  x) { *(m_pData+off)=x; }
  66. inline void SetUINT16(UINT32 off, UINT16 x) { *((UINT16*)(m_pData+off))=x; }
  67. // returns TRUE if PTR points inside of buffer.
  68. // BOOL IsValidPtr(UCHAR* p);
  69. BOOL IsValidOffset(UINT32 n) const;
  70. // make sure that Offset is within the buffer.
  71. // If not, the buffer is automatically resized.
  72. BOOL EnsureValidOffset(UINT32 n);
  73. // copy data into buffer, dynamically growing buffer if needed.
  74. BOOL SafeMemCopy(UINT32 nOffset, const void* data, UINT32 len);
  75. // no bounds checking here.
  76. inline void MemCopy(UINT32 nOffset, const void* data, UINT32 len)
  77. #if _WIN16
  78. HX_ASSERT(len <= ((INT32)1024 * (INT32)64));
  79. #endif
  80. memcpy(m_pData+nOffset, data, (int)len); /* Flawfinder: ignore */
  81. }
  82. // grow/shink buffer (does memcpy)
  83. BOOL Resize(UINT32 nSize);
  84. void Free();
  85. protected:
  86. UINT32 RoundUpToGrowSize(UINT32 nSize);
  87. private:
  88. UINT32 m_nSize;
  89. UCHAR* m_pData;
  90. UINT32 m_nGrowBy;
  91. };
  92. /////////////////////////////////////////////////////////////////////
  93. class CHXInfoEncoder : public IHXObjOutStream, 
  94.    public CUnknownIMP
  95. {
  96.     // the IUnknown implementation declaration
  97.     DECLARE_UNKNOWN(CHXInfoEncoder)
  98. public:
  99. CHXInfoEncoder();
  100. ~CHXInfoEncoder();
  101. // Next 8 functions used most when you need to encode an object.
  102. void  EncodeObj(IHXStreamableObj* pObj);
  103. void  EncodeObj(IHXStreamableObj& Obj) {EncodeObj(&Obj);}
  104. void  PerplexEncodeObj(IHXStreamableObj* pObj);
  105. void  PerplexEncodeObj(IHXStreamableObj& Obj) {PerplexEncodeObj(&Obj);}
  106. void  HexEncodeObj(IHXStreamableObj* pObj);
  107. void  HexEncodeObj(IHXStreamableObj& Obj) {HexEncodeObj(&Obj);}
  108. // After using one of these two functions, the data retreived from
  109. // GetBuffer() will be either perplexed or hexed. Don't bother using these
  110. // if you're using PerplexEncodeObj() or HexEncodeObj(), since those
  111. // methods do an implicit 'Perplex()' or 'Hex()' for you.
  112. // Misuse of the encoder can cause these to fail, so check the return
  113. // value!
  114. BOOL Perplex(); // returns false if perplexing failed for any reason
  115. BOOL Hex(); // returns false if hex failed for any reason
  116. //** IHXObjOutStream methods **//
  117. STDMETHOD(Initialize) (THIS); // clean out buffers, start fresh!
  118.     STDMETHOD_(UINT32, WriteObj) (THIS_ IHXStreamableObj* pObj);
  119.     STDMETHOD_(UINT32, WriteObj) (THIS_ IHXStreamableObj& Obj) {return this->WriteObj(&Obj); }
  120. STDMETHOD_(UINT32, WriteUCHAR) (THIS_ UCHAR nValue);
  121.     STDMETHOD_(UINT32, WriteUINT16) (THIS_ UINT16 nValue);
  122.     STDMETHOD_(UINT32, WriteUINT32) (THIS_ UINT32 nValue);
  123.     STDMETHOD_(UINT32, WriteString) (THIS_ const char* szValue);
  124.     STDMETHOD_(UINT32, WriteStringCat) (THIS_ const char* szValue1,const char* szValue2,const char* szValue3=NULL);
  125.     STDMETHOD_(UINT32, WriteLargeString) (THIS_ const char* szValue);
  126.     STDMETHOD_(UINT32, WriteBuffer)  (THIS_ const char* szBuffer, UINT32 nSize);
  127. // dump at specific positions (earlier positions than current offset)
  128.     STDMETHOD_(UINT32, WriteUINT16At) (THIS_ UINT32 nOffset, UINT16 nValue);
  129.     STDMETHOD_(UINT32, WriteUINT32At) (THIS_ UINT32 nOffset, UINT32 nValue);
  130. // get encoded data and encoded length
  131. STDMETHOD_(const char*, GetBuffer) (THIS);
  132. STDMETHOD_(UINT32, GetLength) (THIS);
  133. // get end of raw data buffer - used when dumping bits into the
  134. // encoder and you want to know the current pos in the buffer
  135. STDMETHOD_(UINT32, GetOffset) (THIS) { return(m_nOffset);}
  136. // basic routines for hex/perplexing, used when this class doesn't
  137. // meet your needs.
  138. static void DumpToHex(char* hex, UCHAR* Bits, UINT32 nSize);
  139. static void DumpToPerplex(char* Perplex, UINT32 ulPerplexSize, UCHAR* Bits, UINT32 nSize);
  140. protected:
  141. static char ToHexNibble(UCHAR hexValue);
  142. static void DumpToMIMEBase64(char* MIMEBase64, const char* Bits, UINT32 nSize);
  143. static char MapToPerplex(UCHAR Perplex);
  144. static void ToPerplex(ULONG32 Input, char* Perplex);
  145. static char MapToMIMEBase64(UCHAR MIMEBase64);
  146. private:
  147. CHXSimpleBuffer m_Buffer;
  148. UINT32 m_nOffset; // current end of data in buffer
  149. UCHAR* m_FinalBuffer;
  150. BOOL m_bFinalBufferAllocFlag;
  151. UINT32 m_nFinalLen; // length of encoded data
  152. };
  153. /////////////////////////////////////////////////////////////////////
  154. class CHXInfoDecoder : public IHXObjInStream, 
  155.    public CUnknownIMP
  156. {
  157.     // the IUnknown implementation declaration
  158.     DECLARE_UNKNOWN(CHXInfoDecoder)
  159. public:
  160. CHXInfoDecoder() : m_Buffer(NULL), m_nDecodedLen(0), m_nOffset(0) {}
  161. ~CHXInfoDecoder() {};
  162. //**** THESE METHODS USED TO LOAD DATA INTO AN IHXStreamableObj OBJECT.
  163. BOOL  PerplexDecodeObj(const char* szPerplex, IHXStreamableObj* pObj);
  164. BOOL  PerplexDecodeObj(const char* szPerplex, IHXStreamableObj& Obj) {return PerplexDecodeObj(szPerplex, &Obj);}
  165. BOOL  PerplexDecodeObj(const char* szPerplex, UINT32 nSize, IHXStreamableObj* pObj);
  166. BOOL  PerplexDecodeObj(const char* szPerplex, UINT32 nSize, IHXStreamableObj& Obj) {return PerplexDecodeObj(szPerplex, nSize, &Obj);}
  167. BOOL  HexDecodeObj(const char* szHex, IHXStreamableObj* pObj);
  168. BOOL  HexDecodeObj(const char* szHex, IHXStreamableObj& Obj) {return HexDecodeObj(szHex, &Obj);}
  169. BOOL  HexDecodeObj(const char* szHex, UINT32 nSize, IHXStreamableObj* pObj);
  170. BOOL  HexDecodeObj(const char* szHex, UINT32 nSize, IHXStreamableObj& Obj) {return PerplexDecodeObj(szHex, nSize, &Obj);}
  171. // for raw data...
  172. BOOL  DecodeObj(const UCHAR* buffer, UINT32 nSize, IHXStreamableObj* pObj);
  173. BOOL  DecodeObj(const UCHAR* buffer, UINT32 nSize, IHXStreamableObj& Obj) {return DecodeObj(buffer, nSize, &Obj);}
  174. BOOL  DecodeObj(const char* buffer, UINT32 nSize, IHXStreamableObj* pObj){return DecodeObj((UCHAR*)buffer, nSize, pObj);}
  175. BOOL  DecodeObj(const char* buffer, UINT32 nSize, IHXStreamableObj& Obj) {return DecodeObj((UCHAR*)buffer, nSize, &Obj);}
  176. STDMETHOD(Initialize) (THIS) {m_Buffer=NULL;m_nOffset=0;m_nDecodedLen=0; return HXR_OK;}
  177. STDMETHOD(Initialize) (THIS_ UCHAR* buf, UINT32 nLen) {m_Buffer=buf;m_nOffset=0;m_nDecodedLen=nLen; return HXR_OK;}
  178.     STDMETHOD_(UINT32, ReadObj) (THIS_ IHXStreamableObj* pObj);
  179.     STDMETHOD_(UINT32, ReadObj) (THIS_ IHXStreamableObj& Obj) {return this->ReadObj(&Obj); }
  180.     STDMETHOD_(UINT32, ReadUCHAR)  (THIS_ UCHAR& nValue);
  181.     STDMETHOD_(UINT32, ReadUINT16) (THIS_ UINT16& nValue);
  182.     STDMETHOD_(UINT32, ReadUINT32) (THIS_ UINT32& nValue);
  183.     STDMETHOD_(UINT32, ReadString) (THIS_ CHXString& strValue);
  184. STDMETHOD_(UINT32, ReadAndAllocCString) (THIS_ char*& pszValue);
  185.     STDMETHOD_(UINT32, ReadLargeString) (THIS_ CHXString& strValue);
  186.     STDMETHOD_(UINT32, ReadAndAllocLargeCString) (THIS_ char*& pszValue);
  187.     STDMETHOD_(UINT32, ReadBuffer)  (THIS_ char* szBuffer, UINT32 nSize);
  188. // STDMETHOD_(UINT32, ReadUTCTime) (THIS_ UTCTimeRep& TimeRep);
  189. STDMETHOD_(BOOL, IsEndOfData) ();
  190. // arbitrarily change offset position.
  191.     STDMETHOD(Seek)  (UINT32 nPos);
  192.     STDMETHOD(SkipForward)  (UINT32 nAmount);
  193. STDMETHOD_(UINT32, GetOffset) (THIS) { return(m_nOffset);}
  194. // get data and length
  195. STDMETHOD_(const char*, GetBuffer) (THIS) {return((char*)m_Buffer);}
  196. STDMETHOD_(UINT32, GetLength) (THIS) {return(m_nDecodedLen);}
  197. //** FUNCTIONS TO DECODE HEX/PERPLEX
  198. static UINT32 SetFromHex(const char* hex, UCHAR* Bits, UINT32 nSize);
  199. static UINT32 SetFromPerplex(const char* Perplex, UCHAR* Bits, UINT32 ulBitsLen, UINT32 nSize);
  200. protected:
  201. // basic functions used internally for decoding perlpex/hex
  202. static UCHAR FromHexNibble(char hexChar);
  203. static UINT32 SetFromMIMEBase64(const char* MIMEBase64, char* Bits, UINT32 nSize);
  204. static UCHAR MapFromPerplex(char Perplex);
  205. static ULONG32 FromPerplex(const char* Perplex);
  206. static UCHAR MapFromMIMEBase64(char MIMEBase64);
  207. private:
  208. UCHAR* m_Buffer;   // Ptr to user-supplied data to load into object.
  209. UINT32 m_nDecodedLen; // actual end of data in buffer
  210. UINT32 m_nOffset;     // current position in buffer
  211. };
  212. #endif