Foxit PDF Conversion SDK

fx_basic.h
浏览该文件的文档.
1
15 //<<<+++OPENSOURCE
16 //<<<+++OPENSOURCE_LICENSE
17 //<<<+++OPENSOURCE_BEGIN LIC==FOXIT||LIC==GOOGLE
18
23 //<<<+++OPENSOURCE_MUST_BEGIN
24 #ifndef _FX_BASIC_H_
25 #define _FX_BASIC_H_
26
27 /* System dependant definitions */
28 #ifndef _FX_SYSTEM_H_
29 #include "fx_system.h"
30 #endif
31 #ifndef _FX_MEMORY_H_
32 #include "fx_memory.h"
33 #endif
34 #ifndef _FX_STRING_H_
35 #include "fx_string.h"
36 #endif
37 #ifndef _FX_STREAM_H_
38 #include "fx_stream.h"
39 #endif
40 //<<<+++OPENSOURCE_MUST_END
41
42 #ifndef _FX_EXCEPTION_H_
43 #include "fx_exception.h"
44 #endif
45
46 //*****************************************************************************
47 //* 缓冲区
48 //*****************************************************************************
52 class CFX_BinaryBuf : public CFX_Object
53 {
54 public:
60 CFX_BinaryBuf(IFX_Allocator* pAllocator = NULL);
61
68 CFX_BinaryBuf(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
69 //<<<+++OPENSOURCE_END
70
72 ~CFX_BinaryBuf();
73
79 void Clear();
80
90 FX_BOOL EstimateSize(FX_STRSIZE size, FX_STRSIZE alloc_step = 0);
91
100 FX_BOOL AppendBlock(const void* pBuf, FX_STRSIZE size);
101
110 FX_BOOL AppendFill(FX_BYTE byte, FX_STRSIZE count);
111
119 void AppendString(FX_BSTR str) { AppendBlock(str.GetPtr(), str.GetLength()); }
120
128 inline FX_BOOL AppendByte(FX_BYTE byte)
129 {
130 if (m_AllocSize <= m_DataSize)
131 {
132 if (!ExpandBuf(100))
133 return false;
134 }
135 m_pBuffer[m_DataSize++] = byte;
136 return true;
137 }
138
148 FX_BOOL InsertBlock(FX_STRSIZE pos, const void* pBuf, FX_STRSIZE size);
149
158 void AttachData(void* pBuf, FX_STRSIZE size);
159
168 FX_BOOL CopyData(const void* pBuf, FX_STRSIZE size);
179 void TakeOver(CFX_BinaryBuf& other);
180
189 void Delete(int start_index, int count);
190
196 FX_LPBYTE GetBuffer() const { return m_pBuffer; }
197
203 FX_STRSIZE GetSize() const { return m_DataSize; }
204
210 CFX_ByteStringC GetByteString() const;
211
219 void GetByteStringL(CFX_ByteStringL &str) const;
220
226 void DetachBuffer();
227
229 IFX_Allocator* m_pAllocator;
230
231 protected:
232 /* 分配步长。 */
233 FX_STRSIZE m_AllocStep;
234 /* 缓冲区指针。 */
235 FX_LPBYTE m_pBuffer;
236 /* 缓冲区的字节长度。 */
237 FX_STRSIZE m_DataSize;
238 /* 缓冲区分配的字节大小。 */
239 FX_STRSIZE m_AllocSize;
240 /*
241 * 增加分配的缓冲区，而不是数据大小。
242 *
243 * @param[in] size 要增加的字节大小。
244 */
245 FX_BOOL ExpandBuf(FX_STRSIZE size);
246 };
247
251 class CFX_ByteTextBuf : public CFX_BinaryBuf
252 {
253 public:
260 CFX_ByteTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}
261
269 void operator = (FX_BSTR str);
270
278 void AppendChar(int ch) { AppendByte((FX_BYTE)ch); }
279
287 CFX_ByteTextBuf& operator << (int i);
288
296 CFX_ByteTextBuf& operator << (FX_DWORD i);
297
305 CFX_ByteTextBuf& operator<<(FX_INT64 i);
306
314 CFX_ByteTextBuf& operator << (double f);
315
323 CFX_ByteTextBuf& operator << (FX_BSTR lpsz);
324
332 CFX_ByteTextBuf& operator << (const CFX_ByteTextBuf& buf);
333
339 FX_STRSIZE GetLength() const { return m_DataSize; }
340 };
341
345 class CFX_WideTextBuf : public CFX_BinaryBuf
346 {
347 public:
354 CFX_WideTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}
355
363 void operator = (FX_LPCWSTR lpsz);
364
372 void operator = (FX_WSTR str);
373
381 FX_BOOL AppendChar(FX_WCHAR wch);
382
390 CFX_WideTextBuf& operator << (int i);
391
399 CFX_WideTextBuf& operator << (double f);
400
408 CFX_WideTextBuf& operator << (FX_LPCWSTR lpsz);
409
417 CFX_WideTextBuf& operator << (FX_WSTR str);
418
426 CFX_WideTextBuf& operator << (const CFX_WideString &str);
427
435 CFX_WideTextBuf& operator << (const CFX_WideTextBuf& buf);
436
442 FX_STRSIZE GetLength() const { return m_DataSize/sizeof(FX_WCHAR); }
443
449 FX_LPWSTR GetBuffer() const { return (FX_LPWSTR)m_pBuffer; }
450
459 void Delete(int start_index, int count)
460 {
461 CFX_BinaryBuf::Delete(start_index * sizeof(FX_WCHAR), count * sizeof(FX_WCHAR));
462 }
463
469 CFX_WideStringC GetWideString() const;
470
471 void GetWideStringL(CFX_WideStringL& wideText) const;
472
473 };
474
475 //*****************************************************************************
476 //* 存档
477 //*****************************************************************************
484 class CFX_ArchiveSaver : public CFX_Object
485 {
486 public:
493 CFX_ArchiveSaver(IFX_Allocator* pAllocator = NULL) : m_SavingBuf(pAllocator), m_pStream(NULL) {}
494
502 CFX_ArchiveSaver& operator << (FX_BYTE i);
503
511 CFX_ArchiveSaver& operator << (FX_BOOL i);
512
520 CFX_ArchiveSaver& operator << (int i);
521
529 CFX_ArchiveSaver& operator << (FX_DWORD i);
530
538 CFX_ArchiveSaver& operator << (FX_INT64 i);
539
547 CFX_ArchiveSaver& operator << (FX_FLOAT i);
548
556 CFX_ArchiveSaver& operator << (FX_BSTR bstr);
557
565 CFX_ArchiveSaver& operator << (FX_LPCSTR bstr);
566
574 CFX_ArchiveSaver& operator << (const CFX_ByteString& bstr);
575
585 CFX_ArchiveSaver& operator << (FX_LPCWSTR bstr);
586
596 CFX_ArchiveSaver& operator << (const CFX_WideString& wstr);
597
606 void Write(const void* pData, FX_STRSIZE dwSize);
607
613 FX_INTPTR GetLength() const { return m_SavingBuf.GetSize(); }
614
620 FX_LPCBYTE GetBuffer() const { return m_SavingBuf.GetBuffer(); }
621
629 void SetStream(IFX_FileStream* pStream) { m_pStream = pStream; }
630
631 protected:
632 /* 保存数据。 */
633 CFX_BinaryBuf m_SavingBuf;
634 /* 流数据。 */
635 IFX_FileStream* m_pStream;
636 };
637
641 class CFX_ArchiveLoader : public CFX_Object
642 {
643 public:
652 CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize);
653
661 CFX_ArchiveLoader& operator >> (FX_BYTE& i);
662
670 CFX_ArchiveLoader& operator >> (FX_BOOL& i);
671
679 CFX_ArchiveLoader& operator >> (int& i);
680
688 CFX_ArchiveLoader& operator >> (FX_INT64& i);
689
697 CFX_ArchiveLoader& operator >> (FX_DWORD& i);
698
706 CFX_ArchiveLoader& operator >> (FX_FLOAT& i);
707
715 CFX_ArchiveLoader& operator >> (CFX_ByteString& bstr);
716
724 CFX_ArchiveLoader& operator >> (CFX_WideString& wstr);
725
731 FX_BOOL IsEOF();
732
741 FX_BOOL Read(void* pBuf, FX_DWORD dwSize);
742
743 protected:
744 /* 当前加载位置。 */
745 FX_DWORD m_LoadingPos;
746 /* 加载缓冲区。 */
747 FX_LPCBYTE m_pLoadingBuf;
748 /* 加载缓冲区的字节大小。 */
749 FX_DWORD m_LoadingSize;
750 };
751
755 class IFX_BufferArchive
756 {
757 public:
765 IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
766 //<<<+++OPENSOURCE_END
767
771 virtual ~IFX_BufferArchive() {}
772
778 virtual void Clear();
779
785 FX_BOOL Flush();
786
795 FX_INT32 AppendBlock(const void* pBuf, size_t size);
796
804 FX_INT32 AppendByte(FX_BYTE byte);
805
813 FX_INT32 AppendDWord(FX_DWORD i);
814
822 FX_INT32 AppendInt64(FX_INT64 i);
823
831 FX_INT32 AppendString(FX_BSTR lpsz);
832
833 protected:
834 /*
835 * @brief 执行工作，当文本缓冲区满时将被调用。
836 *
837 * @param[in] pBuf 指向二进制缓冲区块的指针。
838 * @param[in] size 缓冲区块的字节大小。
839 *
840 * @return <b>true</b> 表示成功，<b>false</b> 表示失败。
841 */
842 virtual FX_BOOL DoWork(const void* pBuf, size_t size) = 0;
843
844 /* 特殊分配器指针。NULL表示使用默认分配器。 */
845 IFX_Allocator* m_pAllocator;
846
847 /* 缓冲区大小*/
848 FX_STRSIZE m_BufSize;
849 /* 缓冲区。 */
850 FX_LPBYTE m_pBuffer;
851 /* 当前缓冲区长度。 */
852 FX_STRSIZE m_Length;
853 };
854
858 class CFX_FileBufferArchive : public IFX_BufferArchive, public CFX_Object
859 {
860 public:
867 CFX_FileBufferArchive(FX_STRSIZE size = 32768, IFX_Allocator* pAllocator = NULL);
868
872 ~CFX_FileBufferArchive();
873
879 virtual void Clear();
880
886 FX_BOOL Flush();
887
896 FX_BOOL AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover = false);
897
905 FX_BOOL AttachFile(FX_LPCWSTR filename);
906
914 FX_BOOL AttachFile(FX_LPCSTR filename);
915
916 private:
917 /*
918 * 执行工作，当文本缓冲区满时将被调用。
919 *
920 * @param[in] pBuf 指向二进制缓冲区块的指针。
921 * @param[in] size 缓冲区块的字节大小。
922 *
923 * @return <b>true</b> 表示成功，<b>false</b> 表示失败。
924 */
925 virtual FX_BOOL DoWork(const void* pBuf, size_t size);
926
927 /* 文件流。 */
928 IFX_StreamWrite *m_pFile;
929 /* 是否接管文件。 */
930 FX_BOOL m_bTakeover;
931 };
932
937 struct CFX_CharMap
938 {
949 static CFX_CharMap* GetDefaultMapper(FX_INT32 codepage = 0);
950
963 CFX_WideString (*m_GetWideString)(CFX_CharMap* pMap, const CFX_ByteString& bstr);
964
976 CFX_ByteString (*m_GetByteString)(CFX_CharMap* pMap, const CFX_WideString& wstr);
977
983 FX_INT32 (*m_GetCodePage)();
984 };
985
986 //*****************************************************************************
987 //* UTF-8
988 //*****************************************************************************
992 class CFX_UTF8Decoder
993 {
994 public:
1002 CFX_UTF8Decoder(IFX_Allocator* pAllocator = NULL) : m_PendingBytes(0),m_PendingChar(0),m_Buffer(pAllocator) { }
1003
1009 void Clear();
1010
1018 void Input(FX_BYTE byte);
1019
1027 void AppendChar(FX_DWORD ch);
1028
1034 void ClearStatus() { m_PendingBytes = 0; }
1035
1041 CFX_WideStringC GetResult() const { return m_Buffer.GetWideString(); }
1042
1050 void GetResult(CFX_WideStringL &result) const {m_Buffer.GetWideStringL(result);}
1051
1052 protected:
1053 /* 解码状态。 */
1054 int m_PendingBytes;
1055 /* 缓存值。 */
1056 FX_DWORD m_PendingChar;
1057 /* 输出宽字符文本缓冲区。 */
1058 CFX_WideTextBuf m_Buffer;
1059 };
1060
1064 class CFX_UTF8Encoder
1065 {
1066 public:
1072 CFX_UTF8Encoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) { m_UTF16First = 0; }
1073
1081 void Input(FX_WCHAR unicode);
1082
1090 void AppendStr(FX_BSTR str) { m_UTF16First = 0; m_Buffer << str; }
1091
1097 CFX_ByteStringC GetResult() const { return m_Buffer.GetByteString(); }
1098
1106 void GetResult(CFX_ByteStringL &result) const {m_Buffer.GetByteStringL(result);}
1107
1108 protected:
1109 /* 输出字节文本缓冲区。 */
1110 CFX_ByteTextBuf m_Buffer;
1111 /* 编码状态。 */
1112 FX_DWORD m_UTF16First;
1113 };
1114
1122 CFX_ByteString FX_UrlEncode(const CFX_WideString& wsUrl);
1123
1131 CFX_WideString FX_UrlDecode(const CFX_ByteString& bsUrl);
1132
1140 CFX_ByteString FX_EncodeURI(const CFX_WideString& wsURI);
1141
1149 CFX_WideString FX_DecodeURI(const CFX_ByteString& bsURI);
1150
1151 //*****************************************************************************
1152 //* 数组
1153 //*****************************************************************************
1157 class CFX_BasicArray : public CFX_Object
1158 {
1159 public:
1161 IFX_Allocator* m_pAllocator;
1162
1163 protected:
1164 /*
1165 * @brief 使用指定的单元大小构造。
1166 *
1167 * @param[in] unit_size 指定的单元大小。必须大于0且小于2^28。
1168 * @param[in] pAllocator 此类中使用的分配器。<b>NULL</b> 表示使用默认分配器。
1169 * 默认值：<b>NULL</b>。
1170 */
1171 CFX_BasicArray(int unit_size, IFX_Allocator* pAllocator = NULL);
1172 //<<<+++OPENSOURCE_END
1173
1174 /*
1175 * @brief 析构函数。
1176 */
1177 ~CFX_BasicArray();
1178
1179 /*
1180 * @brief 拷贝构造函数。
1181 *
1182 * @param[in] other 另一个CFX_BasicArray对象。
1183 * @param[in] pAllocator 分配器。
1184 */
1185 CFX_BasicArray(const CFX_BasicArray& other, IFX_Allocator* pAllocator = NULL);
1186
1187 /*
1188 * @brief 赋值运算符。
1189 *
1190 * @param[in] other 另一个CFX_BasicArray对象。
1191 *
1192 * @return 当前对象本身的引用。
1193 */
1194 CFX_BasicArray& operator=(const CFX_BasicArray& other);
1195
1196 /*
1197 * @brief 更改分配的大小和增长量。
1198 *
1199 * @param[in] nNewSize 期望的新大小（以元素为单位）。
1200 * @param[in] nGrowBy 期望的增长量（以元素为单位），nGrowBy可以为-1表示增长量不变。
1201 *
1202 * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如参数或内存错误）。
1203 */
1204 FX_BOOL SetSize(int nNewSize, int nGrowBy);
1205
1206 /*
1207 * @brief 追加基本数组。
1208 *
1209 * @param[in] src 输入的基本数组。它必须具有与当前数组相同的单元大小。
1210 *
1211 * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如内存错误）。
1212 */
1213 FX_BOOL Append(const CFX_BasicArray& src);
1214
1215 /*
1216 * @brief 从基本数组复制。
1217 *
1218 * @param[in] src 输入的基本数组。它必须具有与当前数组相同的单元大小。
1219 *
1220 * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如内存错误）。
1221 */
1222 FX_BOOL Copy(const CFX_BasicArray& src);
1223
1224 /*
1225 * @brief 在指定位置插入空间。
1226 *
1227 * @param[in] nIndex 指定基本数组中元素的基于零的索引。
1228 * @param[in] nCount 指定要插入的元素数量。
1229 *
1230 * @return 指向插入空间的字节指针。<b>NULL</b> 表示错误。
1231 */
1232 FX_LPBYTE InsertSpaceAt(int nIndex, int nCount);
1233
1234 /*
1235 * @brief 移除若干元素。
1236 *
1237 * @param[in] nIndex 指定基本数组中要移除的起始元素的基于零的索引。
1238 * @param[in] nCount 指定要移除的元素数量。
1239 *
1240 * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如参数错误）。
1241 */
1242 FX_BOOL RemoveAt(int nIndex, int nCount);
1243
1244 /*
1245 * @brief 在指定位置插入基本数组。
1246 *
1247 * @param[in] nStartIndex 指定要插入位置的起始元素的基于零的索引。
1248 * @param[in] pNewArray 输入的基本数组。它必须具有与当前数组相同的单元大小。
1249 *
1250 * @return <b>true</b> 表示成功，<b>false</b> 表示失败（如参数或内存错误）。
1251 */
1252 FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
1253
1254 /*
1255 * @brief 获取指向元素数据的无类型指针。
1256 *
1257 * @param[in] index 指定元素的基于零的索引。
1258 *
1259 * @return 指向元素数据的无类型指针。<b>NULL</b> 表示错误。
1260 */
1261 const void* GetDataPtr(int index) const;
1262
1263 protected:
1264 /* 实际的数据数组 */
1265 FX_LPBYTE m_pData;
1266 /* 元素数量（upperBound - 1） */
1267 int m_nSize;
1268 /* 最大分配数量 */
1269 int m_nMaxSize;
1270 /* 增长量。 */
1271 int m_nGrowBy;
1272 /* 一个单元的字节数。 */
1273 int m_nUnitSize;
1274 };
1275
1277 template<class TYPE>
1278 class CFX_ArrayTemplate : public CFX_BasicArray
1279 {
1280 public:
1286 enum ErrorType{
1288 invalidArraySize,
1289
1291 memoryAllocationError,
1292
1294 indexOutOfRange
1295 };
1296
1302 CFX_ArrayTemplate(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(TYPE), pAllocator) {}
1303 //<<<+++OPENSOURCE_END
1304
1311 CFX_ArrayTemplate(const CFX_ArrayTemplate& other, IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(other, pAllocator) {}
1312
1322 void FX_Error(ErrorType error,FX_INT32 badIndex=0) const
1323 {
1324 const char *errorMsg[] = {
1325 "Invalid array size",
1326 "Memory allocation error",
1327 "Invalid index:"
1328 };
1329
1330 fprintf(stderr, "%s\n", errorMsg[error]);
1331 if(error == indexOutOfRange)
1332 fprintf(stderr, "%i\n", badIndex);
1333 abort();
1334 }
1335
1341 int GetSize() const { return m_nSize; }
1342
1348 int GetUpperBound() const { return m_nSize-1; }
1349
1358 FX_BOOL SetSize(int nNewSize, int nGrowBy = -1)
1359 {
1360 return CFX_BasicArray::SetSize(nNewSize, nGrowBy);
1361 }
1362
1368 void RemoveAll() { SetSize(0, -1); }
1369
1377 const TYPE GetAt(int nIndex) const {
1378 if (nIndex < 0 || nIndex >= m_nSize)
1379 //return (const TYPE&)(*(volatile const TYPE*)NULL);
1380 //为了避免崩溃，我们输入索引。（原因不明）
1381 FX_Error(indexOutOfRange, nIndex);
1382 return ((const TYPE*)m_pData)[nIndex];
1383 }
1384
1393 FX_BOOL SetAt(int nIndex, TYPE newElement) {
1394 if (nIndex < 0 || nIndex >= m_nSize) return false;
1395 ((TYPE*)m_pData)[nIndex] = newElement;
1396 return true;
1397 }
1398
1406 TYPE& ElementAt(int nIndex)
1407 {
1408 if (nIndex < 0 || nIndex >= m_nSize)
1409 //return *(TYPE*)NULL;
1410 //为了避免崩溃，我们输入索引。（原因不明）
1411 FX_Error(indexOutOfRange, nIndex);
1412 return ((TYPE*)m_pData)[nIndex];
1413 }
1414
1420 const TYPE* GetData() const { return (const TYPE*)m_pData; }
1421
1427 TYPE* GetData() { return (TYPE*)m_pData; }
1428
1437 FX_BOOL SetAtGrow(int nIndex, TYPE newElement)
1438 {
1439 if (nIndex < 0) return false;
1440 if (nIndex >= m_nSize)
1441 if (!SetSize(nIndex+1, -1)) return false;
1442 ((TYPE*)m_pData)[nIndex] = newElement;
1443 return true;
1444 }
1445
1453 FX_BOOL Add(TYPE newElement)
1454 {
1455 if (m_nSize < m_nMaxSize)
1456 m_nSize ++;
1457 else
1458 if (!SetSize(m_nSize+1, -1)) return false;
1459 ((TYPE*)m_pData)[m_nSize-1] = newElement;
1460 return true;
1461 }
1462
1470 FX_BOOL Append(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Append(src); }
1471
1479 FX_BOOL Copy(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Copy(src); }
1480
1488 TYPE* GetDataPtr(int index) { return (TYPE*)CFX_BasicArray::GetDataPtr(index); }
1489
1495 TYPE* AddSpace() { return (TYPE*)CFX_BasicArray::InsertSpaceAt(m_nSize, 1); }
1496
1505 TYPE* InsertSpaceAt(int nIndex, int nCount) { return (TYPE*)CFX_BasicArray::InsertSpaceAt(nIndex, nCount); }
1506
1514 CFX_ArrayTemplate& operator=(const CFX_ArrayTemplate& src) { CFX_BasicArray::operator=(src); return *this; }
1515
1523 const TYPE operator[](int nIndex) const
1524 {
1525 if (nIndex < 0 || nIndex >= m_nSize)
1526 //合并自google trunk r2049，作者：Johnson，日期：2012.12.07
1527 *(volatile char*)0 = '\0';
1528 return ((const TYPE*)m_pData)[nIndex];
1529 }
1530
1538 TYPE& operator[](int nIndex)
1539 {
1540 if (nIndex < 0 || nIndex >= m_nSize)
1541 //合并自google trunk r2049，作者：Johnson，日期：2012.12.07
1542 *(volatile char*)0 = '\0';
1543 return ((TYPE*)m_pData)[nIndex];
1544 }
1545
1555 FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount = 1)
1556 {
1557 if (!InsertSpaceAt(nIndex, nCount)) return false;
1558 while (nCount--)
1559 ((TYPE*)m_pData)[nIndex++] = newElement;
1560 return true;
1561 }
1562
1571 FX_BOOL RemoveAt(int nIndex, int nCount = 1) { return CFX_BasicArray::RemoveAt(nIndex, nCount); }
1572
1581 FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray) { return CFX_BasicArray::InsertAt(nStartIndex, pNewArray); }
1590 int Find(const TYPE& data, int iStart = 0) const
1591 {
1592 if (iStart < 0) return -1;
1593 for (; iStart < (int)m_nSize; iStart ++)
1594 if (((TYPE*)m_pData)[iStart] == data) return iStart;
1595 return -1;
1596 }
1597 };
1598
1600 typedef CFX_ArrayTemplate<FX_BYTE> CFX_ByteArray;
1602 typedef CFX_ArrayTemplate<FX_WORD> CFX_WordArray;
1604 typedef CFX_ArrayTemplate<FX_DWORD> CFX_DWordArray;
1606 typedef CFX_ArrayTemplate<void*> CFX_PtrArray;
1608 typedef CFX_ArrayTemplate<FX_FILESIZE> CFX_FileSizeArray;
1610 typedef CFX_ArrayTemplate<FX_FLOAT> CFX_FloatArray;
1612 typedef CFX_ArrayTemplate<FX_INT32> CFX_Int32Array;
1614 typedef CFX_ArrayTemplate<FX_WCHAR> CFX_WCHARArray;
1615
1624 template <class ObjectClass>
1625 class CFX_ObjectArray : public CFX_BasicArray
1626 {
1627 public:
1633 CFX_ObjectArray(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(ObjectClass), pAllocator) {}
1634
1638 ~CFX_ObjectArray() { RemoveAll(); }
1639
1646 CFX_ObjectArray(const CFX_ObjectArray& other, IFX_Allocator* pAllocator = NULL)
1647 : CFX_BasicArray(sizeof(ObjectClass), pAllocator)
1648 {
1649 Copy(other);
1650 }
1651
1659 CFX_ObjectArray& operator=(const CFX_ObjectArray& other)
1660 {
1661 Copy(other);
1662 return *this;
1663 }
1664
1674 void Add(const ObjectClass& data)
1675 {
1676 #ifndef _FX_NOPLACEMENTNEW_
1677 new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
1678 #else
1679 ::new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
1680 #endif
1681
1682 }
1683
1691 ObjectClass& Add()
1692 {
1693 #ifndef _FX_NOPLACEMENTNEW_
1694 return *(ObjectClass*) new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
1695 #else
1696 return *(ObjectClass*) ::new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
1697 #endif
1698 }
1699
1707 void* AddSpace()
1708 {
1709 return InsertSpaceAt(m_nSize, 1);
1710 }
1711
1722 FX_INT32 Append(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
1723 {
1724 if (nCount == 0) return 0;
1725 FX_INT32 nSize = src.GetSize();
1726 if (!nSize) return 0;
1727 FXSYS_assert(nStart > -1 && nStart < nSize);
1728 if (nCount < 0) nCount = nSize;
1729 if (nStart + nCount > nSize) nCount = nSize - nStart;
1730 if (nCount < 1) return 0;
1731 nSize = m_nSize;
1732 InsertSpaceAt(m_nSize, nCount);
1733 ObjectClass* pStartObj = (ObjectClass*)GetDataPtr(nSize);
1734 nSize = nStart + nCount;
1735 for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++)
1736 {
1737 #ifndef _FX_NOPLACEMENTNEW_
1738 new ((void*)pStartObj) ObjectClass(src[i]);
1739 #else
1740 ::new ((void*)pStartObj) ObjectClass(src[i]);
1741 #endif
1742
1743 }
1744 return nCount;
1745 }
1746
1757 FX_INT32 Copy(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
1758 {
1759 if (this == &src) return 0;
1760 RemoveAll();
1761 if (nCount == 0) return 0;
1762 FX_INT32 nSize = src.GetSize();
1763 if (!nSize) return 0;
1764 FXSYS_assert(nStart > -1 && nStart < nSize);
1765 if (nCount < 0) nCount = nSize;
1766 if (nStart + nCount > nSize) nCount = nSize - nStart;
1767 if (nCount < 1) return 0;
1768 nSize = nStart + nCount;
1769 SetSize(nCount, -1);
1770 ObjectClass* pStartObj = (ObjectClass*)m_pData;
1771 for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++)
1772 {
1773 #ifndef _FX_NOPLACEMENTNEW_
1774 new ((void*)pStartObj) ObjectClass(src[i]);
1775 #else
1776 ::new ((void*)pStartObj) ObjectClass(src[i]);
1777 #endif
1778
1779 }
1780 return nCount;
1781 }
1782
1788 int GetSize() const {return m_nSize;}
1789
1797 ObjectClass& operator[] (int index) const
1798 {
1799 FXSYS_assert(index < m_nSize);
1800 return *(ObjectClass*)CFX_BasicArray::GetDataPtr(index);
1801 }
1802
1810 ObjectClass* GetDataPtr(int index) const {return (ObjectClass*)CFX_BasicArray::GetDataPtr(index);}
1811
1819 void RemoveAt(int index)
1820 {
1821 FXSYS_assert(index < m_nSize);
1822 ((ObjectClass*)GetDataPtr(index))->~ObjectClass();
1823 CFX_BasicArray::RemoveAt(index, 1);
1824 }
1825
1831 void RemoveAll()
1832 {
1833 for (int i = 0; i < m_nSize; i ++)
1834 ((ObjectClass*)GetDataPtr(i))->~ObjectClass();
1835 CFX_BasicArray::SetSize(0, -1);
1836 }
1837 };
1838
1840 typedef CFX_ObjectArray<CFX_ByteString> CFX_ByteStringArray;
1842 typedef CFX_ObjectArray<CFX_WideString> CFX_WideStringArray;
1843
1847 template <class TYPE>
1848 class CFX_Stack : CFX_Object
1849 {
1850 public:
1852 CFX_Stack() {}
1853
1859 FX_BOOL Empty() const
1860 {
1861 return m_Container.GetSize() == 0;
1862 }
1863
1869 int Size() const
1870 {
1871 return m_Container.GetSize();
1872 }
1873
1879 TYPE& Top()
1880 {
1881 return m_Container[Size() - 1];
1882 }
1883
1889 void Pop()
1890 {
1891 m_Container.RemoveAt(Size() - 1);
1892 }
1893
1901 void Push(const TYPE& val)
1902 {
1903 m_Container.Add(val);
1904 }
1905
1911 void Clear()
1912 {
1913 m_Container.RemoveAll();
1914 }
1915 private:
1916 CFX_ArrayTemplate<TYPE> m_Container;
1917 };
1918
1922 template <class TYPE>
1923 class CFX_ObjectStack : CFX_Object
1924 {
1925 public:
1927 CFX_ObjectStack() {}
1928
1934 FX_BOOL Empty() const
1935 {
1936 return m_Container.GetSize() == 0;
1937 }
1938
1944 int Size() const
1945 {
1946 return m_Container.GetSize();
1947 }
1948
1954 TYPE& Top()
1955 {
1956 return m_Container[Size() - 1];
1957 }
1958
1964 void Pop()
1965 {
1966 m_Container.RemoveAt(Size() - 1);
1967 }
1968
1976 void Push(const TYPE& val)
1977 {
1978 m_Container.Add(val);
1979 }
1980
1981 private:
1982 CFX_ObjectArray<TYPE> m_Container;
1983 };
1984
1988 template <>
1989 class CFX_Stack<CFX_ByteString> : CFX_Object
1990 {
1991 public:
1993 CFX_Stack() {}
1994
2000 FX_BOOL Empty() const
2001 {
2002 return m_Container.GetSize() == 0;
2003 }
2004
2010 int Size() const
2011 {
2012 return m_Container.GetSize();
2013 }
2014
2020 CFX_ByteString& Top()
2021 {
2022 return m_Container[Size() - 1];
2023 }
2024
2030 void Pop()
2031 {
2032 m_Container.RemoveAt(Size() - 1);
2033 }
2034
2042 void Push(const CFX_ByteString& val)
2043 {
2044 m_Container.Add(val);
2045 }
2046
2047 private:
2048 CFX_ObjectArray<CFX_ByteString> m_Container;
2049 };
2050
2054 class CFX_BaseSegmentedArray : public CFX_Object
2055 {
2056 public:
2065 CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8, IFX_Allocator* pAllocator = NULL);
2066
2070 ~CFX_BaseSegmentedArray();
2071
2081 void SetUnitSize(int unit_size, int segment_units, int index_size = 8);
2082
2088 void* Add();
2089
2097 void* GetAt(int index) const;
2098
2104 void RemoveAll();
2105
2114 void Delete(int index, int count = 1);
2115
2121 int GetSize() const { return m_DataSize; }
2122
2128 int GetSegmentSize() const { return m_SegmentSize; }
2129
2135 int GetUnitSize() const { return m_UnitSize; }
2136
2145 void* Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2146
2148 IFX_Allocator* m_pAllocator;
2149 private:
2150 /* 单元大小 */
2151 int m_UnitSize;
2152 /* 每段中的单元数。 */
2153 short m_SegmentSize;
2154 /* 数组中的索引级别数。 */
2155 FX_BYTE m_IndexSize;
2156 /* 索引树中的当前级别。 */
2157 FX_BYTE m_IndexDepth;
2158 /* 数组中的当前单元数。 */
2159 int m_DataSize;
2160 /* 指向段或索引的索引，如果只有一个段则直接指向该段。 */
2161 void* m_pIndex;
2162
2163 void** GetIndex(int seg_index) const;
2164 void* IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2165 void* IterateSegment(FX_LPCBYTE pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2166 };
2167
2171 template <class ElementType>
2172 class CFX_SegmentedArray : public CFX_BaseSegmentedArray
2173 {
2174 public:
2182 CFX_SegmentedArray(int segment_units, int index_size = 8, IFX_Allocator* pAllocator = NULL)
2183 : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size, pAllocator)
2184 {}
2185 //<<<+++OPENSOURCE_END
2186
2194 void Add(ElementType data)
2195 {
2196 *(ElementType*)CFX_BaseSegmentedArray::Add() = data;
2197 }
2198
2206 ElementType& operator [] (int index)
2207 {
2208 return *(ElementType*)CFX_BaseSegmentedArray::GetAt(index);
2209 }
2210 };
2211
2215 template <class DataType, int FixedSize>
2216 class CFX_FixedBufGrow : public CFX_Object
2217 {
2218 public:
2225 CFX_FixedBufGrow(IFX_Allocator* pAllocator = NULL)
2226 : m_pAllocator(pAllocator)
2227 , m_pData(NULL)
2228 {
2229 FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2230 }
2231
2239 CFX_FixedBufGrow(int data_size, IFX_Allocator* pAllocator = NULL)
2240 : m_pAllocator(pAllocator)
2241 , m_pData(NULL)
2242 {
2243 if (data_size > FixedSize)
2244 m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
2245 else
2246 FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2247 }
2248 //<<<+++OPENSOURCE_END
2249
2257 void SetDataSize(int data_size) {
2258 if (m_pData)
2259 FX_Allocator_Free(m_pAllocator, m_pData);
2260 m_pData = NULL;
2261 if (data_size > FixedSize)
2262 m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
2263 else {
2264 FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2265 }
2266 }
2267
2271 ~CFX_FixedBufGrow() { if (m_pData) FX_Allocator_Free(m_pAllocator, m_pData); }
2272
2273 operator DataType*() { return m_pData ? m_pData : m_Data; }
2274
2275 private:
2276 IFX_Allocator* m_pAllocator;
2277
2278 DataType m_Data[FixedSize];
2279 DataType* m_pData;
2280 };
2281
2285 template <class DataType>
2286 class CFX_TempBuf
2287 {
2288 public:
2296 CFX_TempBuf(int size, IFX_Allocator* pAllocator = NULL) : m_pAllocator(pAllocator)
2297 {
2298 m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, size);
2299 }
2300
2304 ~CFX_TempBuf()
2305 {
2306 if (m_pData) FX_Allocator_Free(m_pAllocator, m_pData);
2307 }
2308 //<<<+++OPENSOURCE_END
2309
2310 DataType& operator[](int i) { FXSYS_assert(m_pData != NULL); return m_pData[i]; }
2311 operator DataType*() const { return m_pData; }
2312
2313 private:
2314 IFX_Allocator* m_pAllocator;
2315
2316 DataType* m_pData;
2317 };
2318
2319 //*****************************************************************************
2320 //* 映射
2321 //*****************************************************************************
2322
2326 class CFX_MapPtrToPtr : public CFX_Object
2327 {
2328 protected:
2332 struct CAssoc
2333 {
2335 CAssoc* pNext;
2337 void* key;
2339 void* value;
2340 };
2341
2342 public:
2350 CFX_MapPtrToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
2351 //<<<+++OPENSOURCE_END
2352
2356 ~CFX_MapPtrToPtr();
2357
2363 int GetCount() const { return m_nCount; }
2364
2370 FX_BOOL IsEmpty() const { return m_nCount == 0; }
2371
2380 FX_BOOL Lookup(void* key, void*& rValue) const;
2381
2389 void* GetValueAt(void* key) const;
2390
2398 void*& operator[](void* key);
2399
2408 void SetAt(void* key, void* newValue) { (*this)[key] = newValue; }
2409
2417 FX_BOOL RemoveKey(void* key);
2418
2424 void RemoveAll();
2425
2431 FX_POSITION GetStartPosition() const { return (m_nCount == 0) ? NULL : (FX_POSITION)-1; }
2432
2445 void GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void*& rValue) const;
2446
2452 FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
2453
2463 void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = true);
2464
2465 protected:
2466 /* 特殊分配器指针。NULL表示使用默认分配器。 */
2467 IFX_Allocator* m_pAllocator;
2468
2469 /* 哈希表。 */
2470 CAssoc** m_pHashTable;
2471 /* 哈希表的大小。 */
2472 FX_DWORD m_nHashTableSize;
2473 /* 映射中键值对的数量。 */
2474 int m_nCount;
2475 /* 内部释放的关联列表。 */
2476 CAssoc* m_pFreeList;
2477 /* 内部块列表。 */
2478 struct CFX_Plex* m_pBlocks;
2479 /* 每个块中关联的大小。 */
2480 int m_nBlockSize;
2481
2482 /*
2483 * 用于用户提供的哈希键的例程。
2484 *
2485 * @note 可重写：特殊非虚拟（有关详细信息，请参阅映射实现）。
2486 *
2487 * @param[in] key 用于生成哈希键的键。
2488 * @return 哈希值。
2489 */
2490 FX_DWORD HashKey(void* key) const;
2491
2492 /*
2493 * 分配新的关联。
2494 *
2495 * @return 指向新分配关联的指针。
2496 */
2497 CAssoc* NewAssoc();
2498 /*
2499 * 释放关联。
2500 *
2501 * @param[in] pAssoc 指向关联的指针。
2502 */
2503 void FreeAssoc(CAssoc* pAssoc);
2504 /*
2505 * @brief 通过键检索关联。
2506 *
2507 * @param[in] key 输入键。
2508 * @param[out] hash 计算的哈希值。
2509 *
2510 * @return 当前关联对象。
2511 */
2512 CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
2513 /*
2514 * @brief 通过位置检索当前关联。
2515 *
2516 * @param[in, out] rNextPosition 输入一个位置，并接收下一个关联位置。
2517 *
2518 * @return 当前关联对象。
2519 */
2520 CAssoc* GetCurrentAssoc(FX_POSITION& rNextPosition) const;
2521 /*
2522 * @brief 将哈希表大小扩展为之前的2倍。
2523 *
2524 * @details 最大哈希表大小为10000。
2525 *
2526 * @return <b>true</b>表示成功，<b>false</b>表示失败。
2527 */
2528 FX_BOOL ExpandHashTable();
2529 private:
2530 CFX_MapPtrToPtr(const CFX_MapPtrToPtr &) FX_EQDELETE;
2531 CFX_MapPtrToPtr &operator=(const CFX_MapPtrToPtr &) FX_EQDELETE;
2532 };
2533
2537 template <class KeyType, class ValueType>
2538 class CFX_MapPtrTemplate : public CFX_MapPtrToPtr
2539 {
2540 public:
2546 CFX_MapPtrTemplate(IFX_Allocator* pAllocator = NULL) : CFX_MapPtrToPtr(10, pAllocator) {}
2547
2556 FX_BOOL Lookup(KeyType key, ValueType& rValue) const
2557 {
2558 FX_LPVOID pValue = NULL;
2559 if (!CFX_MapPtrToPtr::Lookup((void*)(FX_UINTPTR)key, pValue))
2560 return false;
2561 rValue = (ValueType)(FX_UINTPTR)pValue;
2562 return true;
2563 }
2564
2572 ValueType& operator[](KeyType key) { return (ValueType&)CFX_MapPtrToPtr::operator []((void*)(FX_UINTPTR)key); }
2573
2582 void SetAt(KeyType key, ValueType newValue) { CFX_MapPtrToPtr::SetAt((void*)(FX_UINTPTR)key, (void*)(FX_UINTPTR)newValue); }
2583
2591 FX_BOOL RemoveKey(KeyType key) { return CFX_MapPtrToPtr::RemoveKey((void*)(FX_UINTPTR)key); }
2592
2602 void GetNextAssoc(FX_POSITION& rNextPosition, KeyType& rKey, ValueType& rValue) const
2603 {
2604 void* pKey = NULL; void* pValue = NULL;
2605 CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
2606 rKey = (KeyType)(FX_UINTPTR)pKey; rValue = (ValueType)(FX_UINTPTR)pValue;
2607 }
2608 private:
2609 CFX_MapPtrTemplate(const CFX_MapPtrTemplate &) FX_EQDELETE;
2610 CFX_MapPtrTemplate &operator=(const CFX_MapPtrTemplate &) FX_EQDELETE;
2611 };
2612
2617 class CFX_CMapDWordToDWord : public CFX_Object
2618 {
2619 public:
2625 CFX_CMapDWordToDWord(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) {}
2626
2635 FX_BOOL Lookup(FX_DWORD key, FX_DWORD& value) const;
2636
2645 void SetAt(FX_DWORD key, FX_DWORD value);
2646
2655 void EstimateSize(FX_DWORD size, FX_DWORD grow_by);
2656
2662 FX_POSITION GetStartPosition() const;
2663
2673 void GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;
2674
2680 void RemoveAll() { m_Buffer.Clear(); }
2681
2682 protected:
2684 CFX_BinaryBuf m_Buffer;
2685 private:
2686 CFX_CMapDWordToDWord(const CFX_CMapDWordToDWord &) FX_EQDELETE;
2687 CFX_CMapDWordToDWord &operator=(const CFX_CMapDWordToDWord &) FX_EQDELETE;
2688 };
2689
2691 class CFX_MapByteStringToPtr : public CFX_Object
2692 {
2693 protected:
2697 struct CAssoc
2698 {
2700 CAssoc* pNext;
2701
2703 FX_DWORD nHashValue;
2705 CFX_ByteString key;
2707 void* value;
2708 };
2709
2710 public:
2718 CFX_MapByteStringToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
2719
2725 int GetCount() const { return m_nCount; }
2726
2732 FX_BOOL IsEmpty() const { return m_nCount == 0; }
2733
2742 FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;
2743
2751 void*& operator[](FX_BSTR key);
2752
2761 void SetAt(FX_BSTR key, void* newValue) { (*this)[key] = newValue; }
2762
2770 FX_BOOL RemoveKey(FX_BSTR key);
2771
2777 void RemoveAll();
2778
2784 FX_POSITION GetStartPosition() const { return (m_nCount == 0) ? NULL : (FX_POSITION)-1; }
2785
2795 void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
2796
2804 FX_LPVOID GetNextValue(FX_POSITION& rNextPosition) const;
2805
2811 FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
2812
2822 void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = true);
2823
2833 FX_DWORD HashKey(FX_BSTR key) const;
2834
2835 protected:
2836 /* 特殊分配器指针。NULL表示使用默认分配器。 */
2837 IFX_Allocator* m_pAllocator;
2838
2839 /* 哈希表。 */
2840 CAssoc** m_pHashTable;
2841 /* 哈希表的大小。 */
2842 FX_DWORD m_nHashTableSize;
2843 /* 映射中键值对的数量。 */
2844 int m_nCount;
2845 /* 内部释放的关联列表。 */
2846 CAssoc* m_pFreeList;
2847 /* 内部块列表。 */
2848 struct CFX_Plex* m_pBlocks;
2849 /* 每个块中关联的大小。 */
2850 int m_nBlockSize;
2851
2852 /*
2853 * @brief 分配新的关联。
2854 *
2855 * @return 指向新分配关联的指针。
2856 */
2857 CAssoc* NewAssoc();
2858 /*
2859 * @brief 释放关联。
2860 *
2861 * @param[in] pAssoc 指向关联的指针。
2862 *
2863 * @return 无。
2864 */
2865 void FreeAssoc(CAssoc* pAssoc);
2866 /*
2867 * @brief 通过键检索关联。
2868 *
2869 * @param[in] key 输入键。
2870 * @param[out] hash 计算的哈希值。
2871 *
2872 * @return 关联对象。
2873 */
2874 CAssoc* GetAssocAt(FX_BSTR key, FX_DWORD& hash) const;
2875 /*
2876 * @brief 通过位置检索当前关联。
2877 *
2878 * @param[in] rNextPosition 当前位置。
2879 *
2880 * @return 关联对象。
2881 */
2882 CAssoc* GetCurrentAssoc(FX_POSITION& rNextPosition) const;
2883 /*
2884 * @brief 将哈希表大小扩展为之前的2倍。
2885 *
2886 * @details 最大哈希表大小为10000。
2887 *
2888 * @return <b>true</b>表示成功，<b>false</b>表示失败。
2889 */
2890 FX_BOOL ExpendHashTable();
2891
2892 public:
2894 ~CFX_MapByteStringToPtr();
2895 };
2896
2905 class CFX_CMapByteStringToPtr : public CFX_Object
2906 {
2907 public:
2913 CFX_CMapByteStringToPtr(IFX_Allocator* pAllocator = NULL);
2914 //<<<+++OPENSOURCE_END
2915
2917 ~CFX_CMapByteStringToPtr();
2918
2924 void RemoveAll();
2925
2931 FX_POSITION GetStartPosition() const;
2932
2942 void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
2943
2951 FX_LPVOID GetNextValue(FX_POSITION& rNextPosition) const;
2952
2961 FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;
2962
2971 void SetAt(FX_BSTR key, void* value);
2972
2980 void RemoveKey(FX_BSTR key);
2981
2987 int GetCount() const;
2988
3000 void AddValue(FX_BSTR key, void* pValue);
3001
3002 protected:
3003 /* 存储键和值的链式缓冲区。 */
3004 CFX_BaseSegmentedArray m_Buffer;
3005 };
3006
3008 // 列表
3010
3012 class CFX_PtrList : public CFX_Object
3013 {
3014 protected:
3016 struct CNode
3017 {
3019 CNode* pNext;
3021 CNode* pPrev;
3023 void* data;
3024 };
3025
3026 public:
3033 CFX_PtrList(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
3034 //<<<+++OPENSOURCE_END
3035
3041 FX_POSITION GetHeadPosition() const { return (FX_POSITION)m_pNodeHead; }
3042
3048 FX_POSITION GetTailPosition() const { return (FX_POSITION)m_pNodeTail; }
3049
3057 void* GetNext(FX_POSITION& rPosition) const
3058 {
3059 CNode* pNode = (CNode*)rPosition; rPosition = (FX_POSITION)pNode->pNext; return pNode->data;
3060 }
3061
3069 void* GetPrev(FX_POSITION& rPosition) const
3070 {
3071 CNode* pNode = (CNode*)rPosition; rPosition = (FX_POSITION)pNode->pPrev; return pNode->data;
3072 }
3073
3081 FX_POSITION GetNextPosition(FX_POSITION pos) const { return ((CNode*)pos)->pNext; }
3082
3090 FX_POSITION GetPrevPosition(FX_POSITION pos) const { return ((CNode*)pos)->pPrev; }
3091
3099 void* GetAt(FX_POSITION rPosition) const
3100 {
3101 CNode* pNode = (CNode*)rPosition; return pNode ? pNode->data : NULL;
3102 }
3103
3109 int GetCount() const { return m_nCount; }
3110
3118 FX_POSITION AddTail(void* newElement);
3119
3127 FX_POSITION AddHead(void* newElement);
3128
3137 void SetAt(FX_POSITION pos, void* newElement)
3138 {
3139 CNode* pNode = (CNode*)pos; pNode->data = newElement;
3140 }
3141
3150 FX_POSITION InsertAfter(FX_POSITION pos, void* newElement);
3151
3160 FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL ) const;
3161
3169 FX_POSITION FindIndex(int index) const;
3170
3178 void RemoveAt(FX_POSITION pos);
3179
3185 void RemoveAll();
3186
3187 protected:
3188 /* 特殊分配器指针。<b>NULL</b>表示使用默认分配器。 */
3189 IFX_Allocator* m_pAllocator;
3190
3191 /* 指向头部的指针。 */
3192 CNode* m_pNodeHead;
3193 /* 指向尾部的指针。 */
3194 CNode* m_pNodeTail;
3195 /* 列表中节点的数量。 */
3196 int m_nCount;
3197 /* 内部释放的节点列表。 */
3198 CNode* m_pNodeFree;
3199 /* 内部块列表。 */
3200 struct CFX_Plex* m_pBlocks;
3201 /* 每个块中节点的大小。 */
3202 int m_nBlockSize;
3203
3204 /*
3205 * 分配新节点。
3206 *
3207 * @param[in] pPrev 指向前一个节点的指针。
3208 * @param[in] pNext 指向下一个节点的指针。
3209 *
3210 * @return 指向新节点的指针。
3211 */
3212 CNode* NewNode(CNode* pPrev, CNode* pNext);
3213 /*
3214 * 释放节点。
3215 *
3216 * @param[in] pNode 节点指针。
3217 */
3218 void FreeNode(CNode* pNode);
3219
3220 public:
3222 ~CFX_PtrList();
3223 };
3224
3225 //*****************************************************************************
3226 //* 实用工具
3227 //*****************************************************************************
3228
3232 typedef void (*PD_CALLBACK_FREEDATA)(FX_LPVOID pData);
3233
3237 struct FX_PRIVATEDATA
3238 {
3244 void FreeData();
3245
3247 FX_LPVOID m_pModuleId;
3248
3250 FX_LPVOID m_pData;
3251
3253 PD_CALLBACK_FREEDATA m_pCallback;
3254
3259 FX_BOOL m_bSelfDestruct;
3260 };
3261
3265 class CFX_PrivateData
3266 {
3267 public:
3273 CFX_PrivateData(IFX_Allocator* pAllocator = NULL) : m_DataList(pAllocator) {}
3274
3276 ~CFX_PrivateData();
3277
3283 void ClearAll();
3284
3301 void SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback);
3302
3315 void SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject* pObj);
3316
3327 FX_LPVOID GetPrivateData(FX_LPVOID module_id);
3328
3337 FX_BOOL LookupPrivateData(FX_LPVOID module_id, FX_LPVOID &pData) const
3338 {
3339 if (!module_id) return false;
3340 FX_DWORD nCount = m_DataList.GetSize();
3341 for (FX_DWORD n = 0; n < nCount; n++) {
3342 if (m_DataList[n].m_pModuleId == module_id) {
3343 pData = m_DataList[n].m_pData;
3344 return true;
3345 }
3346 }
3347 return false;
3348 }
3349
3359 FX_BOOL RemovePrivateData(FX_LPVOID module_id);
3360
3361 protected:
3362 /* 私有数据数组。 */
3363 CFX_ArrayTemplate<FX_PRIVATEDATA> m_DataList;
3364 /*
3365 * 添加私有数据。如果不存在则添加，否则修改。
3366 *
3367 * @param[in] module_id 模块id。
3368 * @param[in] pData 私有数据。
3369 * @param[in] callback 用于释放提供的私有数据的回调函数。
3370 * @param[in] bSelfDestruct 私有数据是否实际上是CFX_DestructObject派生对象。
3371 *
3372 * @return 无。
3373 */
3374 void AddData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct);
3375 };
3376
3381 class CFX_BitStream : public CFX_Object
3382 {
3383 public:
3392 void Init(FX_LPCBYTE pData, FX_DWORD dwSize);
3393
3401 FX_DWORD GetBits(FX_DWORD nBits);
3402
3408 void ByteAlign();
3409
3415 FX_BOOL IsEOF() const { return m_BitPos >= m_BitSize; }
3416
3424 void SkipBits(FX_DWORD nBits) { m_BitPos += nBits; }
3425
3431 void Rewind() { m_BitPos = 0; }
3432
3433 protected:
3434 /* 位位置（从零开始）。 */
3435 FX_DWORD m_BitPos;
3436 /* 内存块中的总位数。 */
3437 FX_DWORD m_BitSize;
3438 /* 位流缓冲区。 */
3439 FX_LPCBYTE m_pData;
3440 };
3441
3445 class CFX_BitWriter : public CFX_Object
3446 {
3447 public:
3453 CFX_BitWriter(CFX_BinaryBuf* pBinBuf) :m_pBinBuf(pBinBuf), m_BitPos(0), m_BytePos(0) {}
3454
3463 void WriteBits(FX_INT64 value, FX_INT32 nBits);
3464
3470 void ByteAlign();
3471
3477 int GetCurBytePos() { return m_BytePos; }
3478
3479 protected:
3480 /* 动态二进制缓冲区。 */
3481 CFX_BinaryBuf * m_pBinBuf;
3482 /* 位位置（从零开始）。 */
3483 int m_BitPos;
3484 /* 字节位置（从零开始）。 */
3485 int m_BytePos;
3486 };
3487
3492 template <class ObjClass> class CFX_CountRef : public CFX_Object
3493 {
3494 public:
3496 typedef CFX_CountRef<ObjClass> Ref;
3497
3501 class CountedObj : public ObjClass
3502 {
3503 public:
3505 CountedObj():m_RefCount(0) {}
3506
3512 CountedObj(const CountedObj& src) : ObjClass(src) ,m_RefCount(0){}
3513
3515 int m_RefCount;
3516 };
3517
3521 CFX_CountRef()
3522 {
3523 m_pObject = NULL;
3524 }
3525
3531 CFX_CountRef(const Ref& ref)
3532 {
3533 m_pObject = ref.m_pObject;
3534 if (m_pObject) m_pObject->m_RefCount ++;
3535 }
3536
3540 ~CFX_CountRef()
3541 {
3542 if (!m_pObject) return;
3543 m_pObject->m_RefCount --;
3544 if (m_pObject->m_RefCount <= 0) {
3545 delete m_pObject;
3546 m_pObject = NULL;
3547 }
3548 }
3549
3556 ObjClass* New()
3557 {
3558 if (m_pObject) {
3559 m_pObject->m_RefCount --;
3560 if (m_pObject->m_RefCount <= 0)
3561 delete m_pObject;
3562 m_pObject = NULL;
3563 }
3564 m_pObject = FX_NEW CountedObj;
3565 if (!m_pObject) return NULL;
3566 m_pObject->m_RefCount = 1;
3567 return m_pObject;
3568 }
3569
3577 void operator = (const Ref& ref)
3578 {
3579 if (ref.m_pObject)
3580 ref.m_pObject->m_RefCount ++;
3581 if (m_pObject) {
3582 m_pObject->m_RefCount --;
3583 if (m_pObject->m_RefCount <= 0)
3584 delete m_pObject;
3585 }
3586 m_pObject = ref.m_pObject;
3587 }
3588
3596 void operator = (void* p)
3597 {
3598 FXSYS_assert(p == 0);
3599 if (m_pObject == NULL) return;
3600 m_pObject->m_RefCount --;
3601 if (m_pObject->m_RefCount <= 0)
3602 delete m_pObject;
3603 m_pObject = NULL;
3604 }
3605
3611 const ObjClass* GetObjectF() const
3612 {
3613 return m_pObject;
3614 }
3620 operator const ObjClass*() const
3621 {
3622 return m_pObject;
3623 }
3624
3630 FX_BOOL IsNull() const
3631 {
3632 return m_pObject == NULL;
3633 }
3639 FX_BOOL NotNull() const
3640 {
3641 return m_pObject != NULL;
3642 }
3643
3652 ObjClass* GetModify()
3653 {
3654 if (m_pObject == NULL) {
3655 m_pObject = FX_NEW CountedObj;
3656 if (m_pObject)
3657 m_pObject->m_RefCount = 1;
3658 } else if (m_pObject->m_RefCount > 1) {
3659 m_pObject->m_RefCount --;
3660 CountedObj* pOldObject = m_pObject;
3661 m_pObject = NULL;
3662 m_pObject = FX_NEW CountedObj(*pOldObject);
3663 if (m_pObject)
3664 m_pObject->m_RefCount = 1;
3665 }
3666 return m_pObject;
3667 }
3668
3674 void SetNull()
3675 {
3676 if (m_pObject == NULL) return;
3677 m_pObject->m_RefCount --;
3678 if (m_pObject->m_RefCount <= 0)
3679 delete m_pObject;
3680 m_pObject = NULL;
3681 }
3682
3690 FX_BOOL operator == (const Ref& ref) const
3691 {
3692 return m_pObject == ref.m_pObject;
3693 }
3694
3700 int RefCount() const
3701 {
3702 return m_pObject ? m_pObject->m_RefCount : 0;
3703 }
3704
3710 void Incref()
3711 {
3712 if (m_pObject == NULL) return;
3713 m_pObject->m_RefCount++;
3714 }
3715
3721 void Decref()
3722 {
3723 if (m_pObject == NULL) return;
3724 m_pObject->m_RefCount--;
3725 if (m_pObject->m_RefCount <= 0) {
3726 delete m_pObject;
3727 m_pObject = NULL;
3728 }
3729 }
3730
3731 protected:
3732 /* 引用计数对象内部。 */
3733 CountedObj* m_pObject;
3734 };
3735
3737 class IFX_Pause
3738 {
3739 public:
3741 virtual ~IFX_Pause() {}
3742
3748 virtual FX_BOOL NeedToPauseNow() = 0;
3749 };
3750
3752 class CFX_DataFilter : public CFX_Object
3753 {
3754 public:
3758 virtual ~CFX_DataFilter();
3759
3767 void SetDestFilter(CFX_DataFilter* pFilter);
3768
3774 FX_BOOL IsEOF() const { return m_bEOF; }
3775
3781 FX_FILESIZE GetSrcPos() const { return m_SrcPos; }
3782
3792 void FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf& dest_buf);
3793
3802 void FilterFinish(CFX_BinaryBuf& dest_buf);
3803
3809 FX_BOOL IsExhaustBuffer() const { return m_bExhaustBuffer; }
3810
3816 FX_BOOL NeedNewSrc();
3817
3823 FX_BOOL Abort() const { return m_bAbort; }
3824
3830 FX_BOOL AbortAll();
3831
3837 void ResetStatistics();
3838
3839 protected:
3840 /* 构造函数。 */
3841 CFX_DataFilter();
3842
3843 virtual void v_FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf& dest_buf) = 0;
3844 virtual void v_FilterFinish(CFX_BinaryBuf& dest_buf) = 0;
3845 virtual void v_ResetStatistics() {};
3846 void ReportEOF(FX_FILESIZE left_input);
3847
3848 /* 源流中的当前位置。 */
3849 FX_FILESIZE m_SrcPos;
3850
3851 /* 存储FilterIn函数的输出数据。*/
3852 CFX_BinaryBuf m_FilterInBuffer;
3853
3854 /* 指示此过滤器是否中止过滤器处理。例如，RunLenFilter遇到错误的输入数据。 */
3855 FX_BOOL m_bAbort;
3856 /* 指示是否遇到EOF。 */
3857 FX_BOOL m_bEOF;
3858 /* 指示此过滤器是否耗尽输入缓冲区。 */
3859 FX_BOOL m_bExhaustBuffer;
3860 /* 过滤器链。 */
3861 CFX_DataFilter* m_pDestFilter;
3862 };
3863
3865 template<typename T>
3866 class CFX_AutoRestorer {
3867 public:
3873 explicit CFX_AutoRestorer(T* location) {
3874 m_Location = location;
3875 m_OldValue = *location;
3876 }
3877
3879 ~CFX_AutoRestorer() { *m_Location = m_OldValue; }
3880 private:
3881 T* m_Location;
3882 T m_OldValue;
3883 };
3884
3886 template <class T>
3887 class CFX_SmartPointer
3888 {
3889 public:
3895 CFX_SmartPointer(T *pObj) : m_pObj(pObj) {}
3896
3898 ~CFX_SmartPointer() {m_pObj->Release();}
3899
3905 T* Get(void) {return m_pObj;}
3906
3912 T& operator *(void) {return *m_pObj;}
3913
3919 T* operator ->(void) {return m_pObj;}
3920
3921 protected:
3922 T *m_pObj;
3923 };
3924
3925 #define FX_DATALIST_LENGTH 1024
3926
3928 template<size_t unit>
3929 class CFX_SortListArray : public CFX_Object
3930 {
3931 protected:
3933 struct DataList {
3935 FX_INT32 start;
3937 FX_INT32 count;
3938 FX_LPBYTE data;
3939 DataList()
3940 {
3941 start = count = 0;
3942 data = NULL;
3943 }
3944 };
3945
3946 public:
3952 CFX_SortListArray(IFX_Allocator* pAllocator = NULL) : m_CurList(0), m_DataLists(pAllocator) {}
3953
3955 ~CFX_SortListArray()
3956 {
3957 Clear();
3958 }
3959
3965 void Clear()
3966 {
3967 IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
3968
3969 for (FX_INT32 i = m_DataLists.GetUpperBound(); i >= 0; i--){
3970 DataList list = m_DataLists.ElementAt(i);
3971 if (list.data) FX_Allocator_Free(pAllocator, list.data);
3972 }
3973 m_DataLists.RemoveAll();
3974 m_CurList = 0;
3975 }
3976
3985 void Append(FX_INT32 nStart, FX_INT32 nCount)
3986 {
3987 if (nStart < 0) return;
3988
3989 IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
3990
3991 while (nCount > 0){
3992 FX_INT32 temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
3993 DataList list;
3994
3995 list.data = FX_Allocator_Alloc(pAllocator, FX_BYTE, temp_count * unit);
3996 if (!list.data) break;
3997 FXSYS_memset32(list.data, 0, temp_count * unit);
3998 list.start = nStart;
3999 list.count = temp_count;
4000
4001 FX_BOOL ret = Append(list);
4002 if(ret)
4003 {
4004 nCount -= temp_count;
4005 nStart += temp_count;
4006 }
4007 else
4008 {
4009 if (list.data) FX_Allocator_Free(pAllocator, list.data);
4010 return;
4011 }
4012 }
4013 }
4014
4022 FX_LPBYTE GetAt(FX_INT32 nIndex)
4023 {
4024 if (nIndex < 0) return NULL;
4025 if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) return NULL;
4026 DataList *pCurList = m_DataLists.GetDataPtr(m_CurList);
4027 if (!pCurList || nIndex < pCurList->start || nIndex >= pCurList->start + pCurList->count){
4028 pCurList = NULL;
4029 FX_INT32 iStart = 0;
4030 FX_INT32 iEnd = m_DataLists.GetUpperBound();
4031 while (iStart <= iEnd){
4032 FX_INT32 iMid = (iStart + iEnd) / 2;
4033 DataList* list = m_DataLists.GetDataPtr(iMid);
4034 if (nIndex < list->start)
4035 iEnd = iMid - 1;
4036 else if (nIndex >= list->start + list->count)
4037 iStart = iMid + 1;
4038 else {
4039 pCurList = list;
4040 m_CurList = iMid;
4041 break;
4042 }
4043 }
4044 }
4045 return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;
4046 }
4047
4048 protected:
4049 FX_BOOL Append(const DataList& list)
4050 {
4051 FX_INT32 iStart = 0;
4052 FX_INT32 iEnd = m_DataLists.GetUpperBound();
4053 FX_INT32 iFind = 0;
4054 while (iStart <= iEnd) {
4055 FX_INT32 iMid = (iStart + iEnd) / 2;
4056 DataList* cur_list = m_DataLists.GetDataPtr(iMid);
4057 if (list.start == cur_list->start){
4058 return false; // 列表重叠，无操作
4059 } else if (list.start < cur_list->start + cur_list->count)
4060 iEnd = iMid - 1;
4061 else{
4062 if (iMid == iEnd){
4063 iFind = iMid + 1;
4064 break;
4065 }
4066 DataList* next_list = m_DataLists.GetDataPtr(iMid + 1);
4067 if (list.start == next_list->start){
4068 return false; // 列表重叠，无操作
4069 } else if (list.start < next_list->start){
4070 iFind = iMid + 1;
4071 break;
4072 } else {
4073 iStart = iMid + 1;
4074 }
4075 }
4076 }
4077 m_DataLists.InsertAt(iFind, list);
4078 return true;
4079 }
4080
4081 FX_INT32 m_CurList;
4082 CFX_ArrayTemplate<DataList> m_DataLists;
4083 };
4084
4086 template<typename T1, typename T2>
4087 class CFX_ListArrayTemplate : public CFX_Object
4088 {
4089 public:
4095 void Clear()
4096 {
4097 m_Data.Clear();
4098 }
4099
4108 void Add(FX_INT32 nStart, FX_INT32 nCount)
4109 {
4110 m_Data.Append(nStart, nCount);
4111 }
4112
4120 T2& operator [] (FX_INT32 nIndex)
4121 {
4122 FX_LPBYTE data = m_Data.GetAt(nIndex);
4123 FXSYS_assert(data != NULL);
4124
4125 return (T2&)(*(volatile T2*)data);
4126 }
4127
4135 T2* GetPtrAt(FX_INT32 nIndex)
4136 {
4137 return (T2*)m_Data.GetAt(nIndex);
4138 }
4139 protected:
4140 T1 m_Data;
4141 };
4142
4144 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_FILESIZE)>, FX_FILESIZE> CFX_FileSizeListArray;
4146 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_DWORD)>, FX_DWORD> CFX_DWordListArray;
4147
4153 typedef enum {
4155 Ready,
4157 ToBeContinued,
4159 Found,
4161 NotFound,
4163 Failed,
4165 Done
4166 } FX_ProgressiveStatus;
4167
4168 #define ProgressiveStatus FX_ProgressiveStatus
4169
4170 #ifdef _FX_NO_NAMESPACE_
4171 //<<<+++OPENSOURCE_BEGIN LIC==FOXIT
4172 #define FX_NAMESPACE_DECLARE(namespace, type) type
4173 //<<<+++OPENSOURCE_END
4174 #else
4175 //<<<+++OPENSOURCE_BEGIN LIC==GOOGLE
4176 #define FX_NAMESPACE_DECLARE(namespace, type) namespace::type
4177 //<<<+++OPENSOURCE_END
4178 #endif
4179
4181 class IFX_Unknown
4182 {
4183 public:
4189 virtual FX_DWORD Release() = 0;
4190
4196 virtual FX_DWORD AddRef() = 0;
4197
4198 protected:
4199 virtual ~IFX_Unknown() {}
4200 };
4201
4203 #define FX_IsOdd(a) ((a) & 1)
4204
4205 //<<<+++OPENSOURCE_MUST_END
4206
4207 //<<<+++OPENSOURCE_MUST_BEGIN
4208 #endif // _FX_BASIC_H_
4209 //<<<+++OPENSOURCE_MUST_END
4210
4213 //<<<+++OPENSOURCE_END
CFX_DataFilter
Definition: fx_basic.h:3752
CFX_MapByteStringToPtr::GetNextAssoc
void GetNextAssoc(FX_POSITION &rNextPosition, CFX_ByteString &rKey, void *&rValue) const
获取当前关联并将位置设置为下一个关联。
CFX_MapByteStringToPtr::SetAt
void SetAt(FX_BSTR key, void *newValue)
添加新的(键, 值)对。如果不存在则添加，否则修改。
Definition: fx_basic.h:2761
CFX_CMapByteStringToPtr::GetStartPosition
FX_POSITION GetStartPosition() const
获取第一个键值对位置。用于遍历所有(键, 值)对。
CFX_PrivateData
Definition: fx_basic.h:3265
CFX_WideTextBuf::operator<<
CFX_WideTextBuf & operator<<(int i)
左移(<<)运算符重载。将整数输出到宽字符文本缓冲区。
CFX_PtrList::CNode::pNext
CNode * pNext
指向下一个节点的指针。
Definition: fx_basic.h:3019
CFX_UTF8Decoder::GetResult
CFX_WideStringC GetResult() const
获取结果。
Definition: fx_basic.h:1041
FX_LPVOID
void * FX_LPVOID
指向任意类型的指针。
Definition: fx_system.h:654
CFX_MapByteStringToPtr::RemoveAll
void RemoveAll()
移除映射中的所有(键, 值)对。
CFX_BinaryBuf
为更高效追加而设计的动态二进制缓冲区。
Definition: fx_basic.h:52
CFX_BaseSegmentedArray
Definition: fx_basic.h:2054
IFX_Unknown
Definition: fx_basic.h:4181
Ready
就绪。
Definition: fx_basic.h:4155
CFX_MapByteStringToPtr::~CFX_MapByteStringToPtr
~CFX_MapByteStringToPtr()
析构函数。
CFX_ListArrayTemplate::operator []
T2 & operator [](FX_INT32 nIndex)
下标([])运算符重载。
Definition: fx_basic.h:4120
CFX_ObjectArray::Add
void Add(const ObjectClass &data)
向数组添加现有对象的副本。
Definition: fx_basic.h:1674
fx_stream.h
流相关定义和类的头文件。
FX_WCHAR
wchar_t FX_WCHAR
编译器相关的Unicode字符（Microsoft编译器为16位，gcc为32位）。
Definition: fx_system.h:732
CFX_PtrList::CNode
CFX_PtrList中的双向节点。
Definition: fx_basic.h:3016
FX_PRIVATEDATA::m_pModuleId
FX_LPVOID m_pModuleId
模块ID
Definition: fx_basic.h:3247
CFX_UTF8Encoder::GetResult
CFX_ByteStringC GetResult() const
获取结果。
Definition: fx_basic.h:1097
CFX_ArrayTemplate::operator[]
TYPE & operator[](int nIndex)
下标([])运算符重载。此函数返回由nIndex中的基于零的索引指定的指定元素的引用。
Definition: fx_basic.h:1538
FX_DWORD
unsigned long FX_DWORD
32位无符号整数。
Definition: fx_system.h:726
CFX_UTF8Encoder
Definition: fx_basic.h:1064
CFX_PrivateData::RemovePrivateData
FX_BOOL RemovePrivateData(FX_LPVOID module_id)
移除之前存储的私有数据。FPDFAPI假定模块已释放数据， 因此不会调用释放数据回调。
CFX_WideTextBuf::AppendChar
FX_BOOL AppendChar(FX_WCHAR wch)
追加单个宽字符。
CFX_Stack< CFX_ByteString >::Size
int Size() const
获取容器的大小。
Definition: fx_basic.h:2010
CFX_MapPtrToPtr::IsEmpty
FX_BOOL IsEmpty() const
验证映射是否为空。
Definition: fx_basic.h:2370
CFX_PtrList::InsertAfter
FX_POSITION InsertAfter(FX_POSITION pos, void *newElement)
在指定位置后插入一个值。
CFX_WideStringC
常量宽字符串类
Definition: fx_string.h:1210
NotFound
未找到。
Definition: fx_basic.h:4161
CFX_MapByteStringToPtr::CAssoc
CFX_MapByteStringToPtr中的关联。
Definition: fx_basic.h:2697
CFX_BasicArray::m_pAllocator
IFX_Allocator * m_pAllocator
特殊分配器指针。NULL表示使用默认分配器。
Definition: fx_basic.h:1161
CFX_CountRef::Incref
void Incref()
增加引用计数。
Definition: fx_basic.h:3710
CFX_BaseSegmentedArray::Delete
void Delete(int index, int count=1)
删除一定数量的元素。
CFX_Stack
Definition: fx_basic.h:1848
CFX_ObjectArray::~CFX_ObjectArray
~CFX_ObjectArray()
析构函数。
Definition: fx_basic.h:1638
CFX_MapPtrToPtr::GetNextAssoc
void GetNextAssoc(FX_POSITION &rNextPosition, void *&rKey, void *&rValue) const
获取当前关联并将位置设置为下一个关联。
FX_Allocator_Alloc
#define FX_Allocator_Alloc(fxAllocator, type, size)
在分配器上进行发布模式分配。
Definition: fx_memory.h:1084
CFX_ByteStringC::GetLength
FX_STRSIZE GetLength() const
获取字节字符串的长度。
Definition: fx_string.h:227
CFX_DWordArray
CFX_ArrayTemplate< FX_DWORD > CFX_DWordArray
双字数组类型的类型定义。
Definition: fx_basic.h:1604
CFX_ArrayTemplate::ElementAt
TYPE & ElementAt(int nIndex)
此方法检索由索引号指定的元素的引用。
Definition: fx_basic.h:1406
CFX_ObjectArray::CFX_ObjectArray
CFX_ObjectArray(const CFX_ObjectArray &other, IFX_Allocator *pAllocator=0)
拷贝构造函数。
Definition: fx_basic.h:1646
CFX_CMapByteStringToPtr::AddValue
void AddValue(FX_BSTR key, void *pValue)
向字典添加键值对，假定不存在重复键。
CFX_ListArrayTemplate::GetPtrAt
T2 * GetPtrAt(FX_INT32 nIndex)
获取数据的指针。
Definition: fx_basic.h:4135
CFX_Stack< CFX_ByteString >::Push
void Push(const CFX_ByteString &val)
将字节字符串压入栈中。
Definition: fx_basic.h:2042
CFX_WordArray
CFX_ArrayTemplate< FX_WORD > CFX_WordArray
字数组类型的类型定义。
Definition: fx_basic.h:1602
CFX_PtrList::RemoveAll
void RemoveAll()
移除列表中的所有节点。
CFX_CMapByteStringToPtr::GetCount
int GetCount() const
获取键值对的数量。
CFX_ByteTextBuf::operator<<
CFX_ByteTextBuf & operator<<(int i)
左移(<<)运算符重载。将整数输出到字节文本缓冲区。
CFX_CountRef::IsNull
FX_BOOL IsNull() const
检查对象指针是否为NULL。
Definition: fx_basic.h:3630
CFX_SegmentedArray::operator []
ElementType & operator [](int index)
下标([])运算符重载。此函数返回由从零开始的索引指定的元素的引用。
Definition: fx_basic.h:2206
CFX_FixedBufGrow::CFX_FixedBufGrow
CFX_FixedBufGrow(IFX_Allocator *pAllocator=0)
使用分配器进行构造。
Definition: fx_basic.h:2225
CFX_PtrList::CNode::data
void * data
节点数据。
Definition: fx_basic.h:3023
CFX_CMapDWordToDWord::SetAt
void SetAt(FX_DWORD key, FX_DWORD value)
添加新的(键, 值)对。如果不存在则添加，否则修改。
CFX_CharMap::GetDefaultMapper
static CFX_CharMap * GetDefaultMapper(FX_INT32 codepage=0)
根据Windows代码页或其他编码系统获取字符映射器。 这些字符映射由FXAPI管理，请勿销毁它们。
CFX_ObjectStack::Empty
FX_BOOL Empty() const
清空容器。
Definition: fx_basic.h:1934
CFX_BitStream::Init
void Init(FX_LPCBYTE pData, FX_DWORD dwSize)
使用内存块初始化位流。必须先调用Init()。
CFX_MapByteStringToPtr::CAssoc::key
CFX_ByteString key
键数据。
Definition: fx_basic.h:2705
CFX_MapPtrTemplate::SetAt
void SetAt(KeyType key, ValueType newValue)
添加新的(键, 值)对。如果不存在则添加，否则修改。
Definition: fx_basic.h:2582
CFX_MapByteStringToPtr::GetStartPosition
FX_POSITION GetStartPosition() const
获取第一个键值对位置。用于遍历所有(键, 值)对。
Definition: fx_basic.h:2784
CFX_CharMap::m_GetCodePage
FX_INT32(* m_GetCodePage)()
GetCodePage函数的指针类型。该函数返回平台的代码页。
Definition: fx_basic.h:983
CFX_BinaryBuf::GetByteStringL
void GetByteStringL(CFX_ByteStringL &str) const
从当前缓冲区对象获取字节字符串。
CFX_BinaryBuf::CFX_BinaryBuf
CFX_BinaryBuf(IFX_Allocator *pAllocator=0)
创建空缓冲区的默认构造函数。
CFX_MapPtrToPtr::SetAt
void SetAt(void *key, void *newValue)
添加新的(键, 值)对。如果不存在则添加，否则修改。
Definition: fx_basic.h:2408
PD_CALLBACK_FREEDATA
void(* PD_CALLBACK_FREEDATA)(FX_LPVOID pData)
Definition: fx_basic.h:3232
FX_LPCWSTR
wchar_t const * FX_LPCWSTR
指向常量Unicode字符的指针。
Definition: fx_system.h:736
CFX_ObjectArray::operator=
CFX_ObjectArray & operator=(const CFX_ObjectArray &other)
赋值运算符。
Definition: fx_basic.h:1659
FX_PRIVATEDATA::m_bSelfDestruct
FX_BOOL m_bSelfDestruct
决定是否对私有数据使用自销毁的布尔值。 如果为true，m_pData实际上必须指向CFX_DestructObject派生对象。
Definition: fx_basic.h:3259
CFX_BaseSegmentedArray::Add
void * Add()
添加一个元素。
FX_PRIVATEDATA::m_pData
FX_LPVOID m_pData
私有数据。
Definition: fx_basic.h:3250
CFX_WideTextBuf::CFX_WideTextBuf
CFX_WideTextBuf(IFX_Allocator *pAllocator=0)
使用分配器构造。
Definition: fx_basic.h:354
IFX_BufferArchive::Flush
FX_BOOL Flush()
刷新文件的内部缓冲区。
CFX_DataFilter::FilterFinish
void FilterFinish(CFX_BinaryBuf &dest_buf)
指示输入已完成。 对于某些过滤器，可能会生成一些最后的输出。
CFX_SortListArray::DataList::start
FX_INT32 start
起始索引。
Definition: fx_basic.h:3935
CFX_Stack< CFX_ByteString >::CFX_Stack
CFX_Stack()
构造。
Definition: fx_basic.h:1993
CFX_CountRef::~CFX_CountRef
~CFX_CountRef()
析构引用并释放它引用的对象。
Definition: fx_basic.h:3540
CFX_ObjectArray::RemoveAt
void RemoveAt(int index)
移除指定位置的对象。
Definition: fx_basic.h:1819
CFX_BaseSegmentedArray::GetSize
int GetSize() const
获取数组中元素的数量。
Definition: fx_basic.h:2121
CFX_BitWriter::GetCurBytePos
int GetCurBytePos()
获取当前字节位置。
Definition: fx_basic.h:3477
CFX_PtrList::CFX_PtrList
CFX_PtrList(int nBlockSize=10, IFX_Allocator *pAllocator=0)
使用块大小和分配器进行构造。
CFX_UTF8Decoder::Clear
void Clear()
清除解码状态并将输出宽字符文本缓冲区设为空。
CFX_DataFilter::~CFX_DataFilter
virtual ~CFX_DataFilter()
析构函数。销毁此过滤器及其所有链。
CFX_BitStream::ByteAlign
void ByteAlign()
对齐到字节边界。如果当前位位置不是8的倍数，当前字节的剩余部分将被跳过。
CFX_BaseSegmentedArray::SetUnitSize
void SetUnitSize(int unit_size, int segment_units, int index_size=8)
更改单元大小和段单元数。只能在数组为空时调用。
CFX_DataFilter::FilterIn
void FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf &dest_buf)
向过滤器（及其过滤器链）输入数据块，并接收最终输出。
CFX_PrivateData::ClearAll
void ClearAll()
释放所有剩余数据。
CFX_ArrayTemplate::GetSize
int GetSize() const
获取数组中元素的数量。
Definition: fx_basic.h:1341
CFX_FileBufferArchive::Flush
FX_BOOL Flush()
刷新内部缓冲区。
CFX_BinaryBuf::EstimateSize
FX_BOOL EstimateSize(FX_STRSIZE size, FX_STRSIZE alloc_step=0)
更改已分配的缓冲区大小，如果alloc_step非零则设置分配步长。
CFX_PtrList::GetNextPosition
FX_POSITION GetNextPosition(FX_POSITION pos) const
获取下一个位置。
Definition: fx_basic.h:3081
CFX_SmartPointer::operator *
T & operator *(void)
获取对象引用运算符。
Definition: fx_basic.h:3912
IFX_BufferArchive
Definition: fx_basic.h:755
CFX_PrivateData::GetPrivateData
FX_LPVOID GetPrivateData(FX_LPVOID module_id)
获取之前存储的私有数据。未存储则返回NULL。
CFX_ObjectArray::Copy
FX_INT32 Copy(const CFX_ObjectArray &src, FX_INT32 nStart=0, FX_INT32 nCount=-1)
从数组复制。
Definition: fx_basic.h:1757
CFX_SegmentedArray
Definition: fx_basic.h:2172
CFX_UTF8Encoder::CFX_UTF8Encoder
CFX_UTF8Encoder(IFX_Allocator *pAllocator=0)
构造函数。将编码器设置为初始状态。
Definition: fx_basic.h:1072
CFX_ArchiveSaver::SetStream
void SetStream(IFX_FileStream *pStream)
设置附加的流。
Definition: fx_basic.h:629
CFX_WideTextBuf::operator=
void operator=(FX_LPCWSTR lpsz)
赋值(=)运算符重载。从以零结尾的宽字符字符串。
CFX_TempBuf::CFX_TempBuf
CFX_TempBuf(int size, IFX_Allocator *pAllocator=0)
使用分配器进行构造。
Definition: fx_basic.h:2296
FX_MIN
#define FX_MIN(a, b)
返回a和b中最小值的宏。
Definition: fx_system.h:826
CFX_DataFilter::Abort
FX_BOOL Abort() const
指示是否中止过滤器处理。
Definition: fx_basic.h:3823
CFX_FileBufferArchive::AttachFile
FX_BOOL AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover=false)
附加文件
CFX_UTF8Encoder::GetResult
void GetResult(CFX_ByteStringL &result) const
获取结果。
Definition: fx_basic.h:1106
CFX_CMapDWordToDWord::CFX_CMapDWordToDWord
CFX_CMapDWordToDWord(IFX_Allocator *pAllocator=0)
使用分配器的构造函数。
Definition: fx_basic.h:2625
CFX_BaseSegmentedArray::GetUnitSize
int GetUnitSize() const
获取每个元素的字节数。
Definition: fx_basic.h:2135
CFX_ObjectStack
Definition: fx_basic.h:1923
CFX_WideString
宽字符串类
Definition: fx_string.h:1457
CFX_BinaryBuf::AppendFill
FX_BOOL AppendFill(FX_BYTE byte, FX_STRSIZE count)
将指定字节追加指定次数。内部不是逐字节处理，而是字节填充处理。
CFX_UTF8Decoder::CFX_UTF8Decoder
CFX_UTF8Decoder(IFX_Allocator *pAllocator=0)
构造函数。将解码器设置为初始状态。
Definition: fx_basic.h:1002
CFX_CountRef::Ref
CFX_CountRef< ObjClass > Ref
类型定义：CFX_CountRef<ObjClass>的缩写。
Definition: fx_basic.h:3496
CFX_ObjectArray::CFX_ObjectArray
CFX_ObjectArray(IFX_Allocator *pAllocator=0)
构造函数。
Definition: fx_basic.h:1633
IFX_StreamWrite
流写入接口。
Definition: fx_stream.h:441
CFX_Stack::CFX_Stack
CFX_Stack()
构造。
Definition: fx_basic.h:1852
IFX_Unknown::AddRef
virtual FX_DWORD AddRef()=0
增加引用计数。
CFX_MapByteStringToPtr::CFX_MapByteStringToPtr
CFX_MapByteStringToPtr(int nBlockSize=10, IFX_Allocator *pAllocator=0)
使用指定的块大小进行构造。
FX_POSITION
void * FX_POSITION
用于表示集合中元素位置的值。
Definition: fx_system.h:658
CFX_PrivateData::CFX_PrivateData
CFX_PrivateData(IFX_Allocator *pAllocator=0)
使用分配器进行构造。
Definition: fx_basic.h:3273
IFX_Unknown::Release
virtual FX_DWORD Release()=0
减少引用计数并释放当前对象。
CFX_PtrList::~CFX_PtrList
~CFX_PtrList()
CFX_BaseSegmentedArray::GetSegmentSize
int GetSegmentSize() const
获取每段中元素的数量。
Definition: fx_basic.h:2128
CFX_UTF8Encoder::Input
void Input(FX_WCHAR unicode)
输入Unicode字符。
CFX_ArchiveSaver::GetLength
FX_INTPTR GetLength() const
获取已保存数据的长度。
Definition: fx_basic.h:613
CFX_ArrayTemplate::memoryAllocationError
内存分配错误。
Definition: fx_basic.h:1291
CFX_ArchiveSaver::GetBuffer
FX_LPCBYTE GetBuffer() const
获取指向已保存数据的常量字节指针。
Definition: fx_basic.h:620
CFX_ArchiveLoader::Read
FX_BOOL Read(void *pBuf, FX_DWORD dwSize)
反序列化内存块。
IFX_Pause::NeedToPauseNow
virtual FX_BOOL NeedToPauseNow()=0
检查调用者是否需要立即暂停。
CFX_MapByteStringToPtr::InitHashTable
void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow=true)
初始化哈希表。
CFX_ObjectArray::operator[]
ObjectClass & operator[](int index) const
下标([])运算符重载。此函数返回由nIndex中的基于零的索引指定的指定对象的引用。
Definition: fx_basic.h:1797
CFX_ArrayTemplate::Copy
FX_BOOL Copy(const CFX_ArrayTemplate &src)
从数组复制。
Definition: fx_basic.h:1479
CFX_ArrayTemplate::SetSize
FX_BOOL SetSize(int nNewSize, int nGrowBy=-1)
更改分配的大小和增长量。
Definition: fx_basic.h:1358
CFX_ByteStringC::GetPtr
FX_LPCBYTE GetPtr() const
获取指向字节字符串的常量字节字符串指针。
Definition: fx_string.h:215
CFX_BinaryBuf::Clear
void Clear()
将二进制缓冲区设置为空。
CFX_PrivateData::SetPrivateObj
void SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject *pObj)
设置私有对象。
CFX_WideTextBuf
Definition: fx_basic.h:345
CFX_Stack::Clear
void Clear()
从栈中移除所有剩余数据。
Definition: fx_basic.h:1911
CFX_MapByteStringToPtr::HashKey
FX_DWORD HashKey(FX_BSTR key) const
用于用户提供的哈希键的例程。
CFX_BinaryBuf::m_pAllocator
IFX_Allocator * m_pAllocator
特殊分配器指针。NULL 表示使用默认分配器。
Definition: fx_basic.h:229
CFX_CountRef::CountedObj::m_RefCount
int m_RefCount
引用计数。
Definition: fx_basic.h:3515
CFX_SmartPointer
Definition: fx_basic.h:3887
CFX_FileBufferArchive::CFX_FileBufferArchive
CFX_FileBufferArchive(FX_STRSIZE size=32768, IFX_Allocator *pAllocator=0)
使用大小和分配器的构造函数。
fx_string.h
字符串的头文件，可变长度字符序列。 这里有两种字符串，字节字符串和宽字符串
CFX_MapPtrToPtr::CAssoc::value
void * value
值数据。
Definition: fx_basic.h:2339
CFX_MapPtrToPtr::CFX_MapPtrToPtr
CFX_MapPtrToPtr(int nBlockSize=10, IFX_Allocator *pAllocator=0)
使用指定的块大小进行构造。
CFX_DataFilter::GetSrcPos
FX_INT64 GetSrcPos() const
获取源流中的当前位置（从所有输入数据开始的字节偏移量）。
Definition: fx_basic.h:3781
CFX_ArrayTemplate::Append
FX_BOOL Append(const CFX_ArrayTemplate &src)
追加数组。
Definition: fx_basic.h:1470
CFX_MapPtrTemplate::RemoveKey
FX_BOOL RemoveKey(KeyType key)
移除现有的(键, 值)对。
Definition: fx_basic.h:2591
CFX_SmartPointer::operator ->
T * operator ->(void)
获取对象指针运算符。
Definition: fx_basic.h:3919
FX_INT32
int FX_INT32
32位有符号整数。
Definition: fx_system.h:683
CFX_MapPtrTemplate::Lookup
FX_BOOL Lookup(KeyType key, ValueType &rValue) const
通过键查找。
Definition: fx_basic.h:2556
FXSYS_memset32
void * FXSYS_memset32(void *dst, FX_INT32 v, size_t size)
将缓冲区数据设置为指定值。
CFX_CountRef::CFX_CountRef
CFX_CountRef()
构造空引用。
Definition: fx_basic.h:3521
FX_STRSIZE
int FX_STRSIZE
字符串大小限制为 2^31-1。
Definition: fx_string.h:35
CFX_ArrayTemplate::RemoveAll
void RemoveAll()
清理数组。
Definition: fx_basic.h:1368
CFX_PtrList::GetHeadPosition
FX_POSITION GetHeadPosition() const
获取头部位置。
Definition: fx_basic.h:3041
CFX_CMapDWordToDWord::GetStartPosition
FX_POSITION GetStartPosition() const
获取第一个键值对位置。用于遍历所有(键, 值)对。
CFX_ArrayTemplate::Add
FX_BOOL Add(TYPE newElement)
在尾部添加元素。可能会增长数组。
Definition: fx_basic.h:1453
CFX_Int32Array
CFX_ArrayTemplate< FX_INT32 > CFX_Int32Array
INT32数组的类型定义。
Definition: fx_basic.h:1612
CFX_CMapByteStringToPtr
Definition: fx_basic.h:2905
CFX_ByteTextBuf
Definition: fx_basic.h:251
CFX_ArchiveLoader::IsEOF
FX_BOOL IsEOF()
检查反序列化是否到达加载缓冲区的末尾。
CFX_ByteTextBuf::CFX_ByteTextBuf
CFX_ByteTextBuf(IFX_Allocator *pAllocator=0)
使用分配器构造。
Definition: fx_basic.h:260
CFX_MapPtrToPtr::CAssoc
CFX_MapPtrToPtr中的关联。
Definition: fx_basic.h:2332
CFX_MapByteStringToPtr::GetCount
int GetCount() const
获取元素的数量。
Definition: fx_basic.h:2725
CFX_PrivateData::~CFX_PrivateData
~CFX_PrivateData()
析构函数。
CFX_BinaryBuf::~CFX_BinaryBuf
~CFX_BinaryBuf()
析构函数。
CFX_BaseSegmentedArray::Iterate
void * Iterate(FX_BOOL(*callback)(void *param, void *pData), void *param) const
遍历所有单元，对每个单元执行回调函数。
FX_BOOL
int FX_BOOL
布尔变量（应为TRUE或FALSE）。
Definition: fx_system.h:691
CFX_ArrayTemplate< FX_PRIVATEDATA >::ErrorType
ErrorType
错误类型的枚举。
Definition: fx_basic.h:1286
CFX_CMapDWordToDWord::RemoveAll
void RemoveAll()
移除所有(键, 值)对。
Definition: fx_basic.h:2680
IFX_BufferArchive::Clear
virtual void Clear()
清除文本缓冲区。
CFX_TempBuf::~CFX_TempBuf
~CFX_TempBuf()
析构函数。
Definition: fx_basic.h:2304
CFX_SortListArray
Definition: fx_basic.h:3929
CFX_DataFilter::SetDestFilter
void SetDestFilter(CFX_DataFilter *pFilter)
设置目标过滤器。注意过滤器将被追加到当前过滤器链的末尾。
CFX_ListArrayTemplate
Definition: fx_basic.h:4087
CFX_BitWriter::ByteAlign
void ByteAlign()
对齐到字节边界。如果当前位位置不是8的倍数，当前字节的剩余部分将被跳过。
CFX_ArchiveSaver::operator<<
CFX_ArchiveSaver & operator<<(FX_BYTE i)
左移(<<)运算符重载。序列化单个字节。
FX_LPCSTR
char const * FX_LPCSTR
指向常量8位Windows (ANSI) 字符的指针。
Definition: fx_system.h:705
CFX_UTF8Decoder::AppendChar
void AppendChar(FX_DWORD ch)
将字符追加到宽字符文本缓冲区。
CFX_PtrList
Definition: fx_basic.h:3012
CFX_ObjectArray::Append
FX_INT32 Append(const CFX_ObjectArray &src, FX_INT32 nStart=0, FX_INT32 nCount=-1)
追加数组。
Definition: fx_basic.h:1722
CFX_SortListArray::DataList::count
FX_INT32 count
数据计数。
Definition: fx_basic.h:3937
CFX_SmartPointer::Get
T * Get(void)
获取对象指针。
Definition: fx_basic.h:3905
FX_DecodeURI
CFX_WideString FX_DecodeURI(const CFX_ByteString &bsURI)
简单的URI解码。
CFX_CharMap::m_GetWideString
CFX_WideString(* m_GetWideString)(CFX_CharMap *pMap, const CFX_ByteString &bstr)
GetWideString函数的指针类型。
Definition: fx_basic.h:963
CFX_SortListArray::DataList
数据列表。
Definition: fx_basic.h:3933
CFX_MapPtrTemplate::GetNextAssoc
void GetNextAssoc(FX_POSITION &rNextPosition, KeyType &rKey, ValueType &rValue) const
获取当前关联并将位置设置为下一个关联。
Definition: fx_basic.h:2602
CFX_DataFilter::IsExhaustBuffer
FX_BOOL IsExhaustBuffer() const
指示此过滤器是否耗尽输入缓冲区。
Definition: fx_basic.h:3809
CFX_SortListArray::GetAt
FX_LPBYTE GetAt(FX_INT32 nIndex)
获取数据。
Definition: fx_basic.h:4022
IFX_FileStream
文件流接口，用于读取和写入。
Definition: fx_stream.h:692
CFX_ArrayTemplate::SetAtGrow
FX_BOOL SetAtGrow(int nIndex, TYPE newElement)
在指定位置设置元素值。可能会增长数组。
Definition: fx_basic.h:1437
Found
已找到。
Definition: fx_basic.h:4159
CFX_UTF8Encoder::AppendStr
void AppendStr(FX_BSTR str)
追加非缓冲字节字符串。
Definition: fx_basic.h:1090
CFX_ObjectStack::CFX_ObjectStack
CFX_ObjectStack()
构造。
Definition: fx_basic.h:1927
IFX_BufferArchive::AppendBlock
FX_INT32 AppendBlock(const void *pBuf, size_t size)
追加二进制缓冲区块。
CFX_UTF8Decoder::GetResult
void GetResult(CFX_WideStringL &result) const
获取结果。
Definition: fx_basic.h:1050
CFX_FileSizeArray
CFX_ArrayTemplate< FX_INT64 > CFX_FileSizeArray
文件大小数组类型的类型定义。
Definition: fx_basic.h:1608
FX_UINTPTR
UINT_PTR FX_UINTPTR
指针精度的无符号整型。
Definition: fx_system.h:752
CFX_ArrayTemplate::InsertSpaceAt
TYPE * InsertSpaceAt(int nIndex, int nCount)
插入若干元素。
Definition: fx_basic.h:1505
CFX_PtrList::RemoveAt
void RemoveAt(FX_POSITION pos)
移除指定位置的节点。
CFX_MapByteStringToPtr::RemoveKey
FX_BOOL RemoveKey(FX_BSTR key)
移除现有键。
CFX_CountRef::RefCount
int RefCount() const
获取引用计数。
Definition: fx_basic.h:3700
CFX_ArrayTemplate::RemoveAt
FX_BOOL RemoveAt(int nIndex, int nCount=1)
在指定位置移除若干元素。
Definition: fx_basic.h:1571
IFX_Pause
Definition: fx_basic.h:3737
CFX_BitStream::Rewind
void Rewind()
倒带位流。简单地将当前位位置设置为零。
Definition: fx_basic.h:3431
CFX_MapByteStringToPtr::GetHashTableSize
FX_DWORD GetHashTableSize() const
获取内部哈希表大小。派生类的高级功能。
Definition: fx_basic.h:2811
CFX_WideStringArray
CFX_ObjectArray< CFX_WideString > CFX_WideStringArray
CFX_WideString数组类型的类型定义。
Definition: fx_basic.h:1842
CFX_MapPtrToPtr::operator[]
void *& operator[](void *key)
下标([])运算符重载。查找，如果不存在则添加。
CFX_BinaryBuf::AttachData
void AttachData(void *pBuf, FX_STRSIZE size)
附加到缓冲区（此缓冲区将属于此对象）。缓冲区必须由FX_Alloc分配。
CFX_CountRef::operator=
void operator=(const Ref &ref)
赋值(=)运算符重载。从另一个引用赋值。
Definition: fx_basic.h:3577
CFX_PtrList::GetNext
void * GetNext(FX_POSITION &rPosition) const
获取当前值并将位置设置为下一个节点。
Definition: fx_basic.h:3057
CFX_MapByteStringToPtr::CAssoc::nHashValue
FX_DWORD nHashValue
缓存的哈希值，高效迭代所需。
Definition: fx_basic.h:2703
CFX_BinaryBuf::DetachBuffer
void DetachBuffer()
分离缓冲区。仅将缓冲区指针设置为 NULL，并将二进制缓冲区大小设置为零。
CFX_PtrList::GetPrev
void * GetPrev(FX_POSITION &rPosition) const
获取当前值并将位置设置为前一个节点。
Definition: fx_basic.h:3069
CFX_ArrayTemplate::CFX_ArrayTemplate
CFX_ArrayTemplate(const CFX_ArrayTemplate &other, IFX_Allocator *pAllocator=0)
拷贝构造函数。
Definition: fx_basic.h:1311
CFX_ObjectArray::AddSpace
void * AddSpace()
向数组添加空空间。
Definition: fx_basic.h:1707
CFX_ObjectStack::Top
TYPE & Top()
获取栈顶的类型对象。
Definition: fx_basic.h:1954
CFX_PtrList::AddTail
FX_POSITION AddTail(void *newElement)
向尾部添加一个值。
CFX_ArchiveSaver::Write
void Write(const void *pData, FX_STRSIZE dwSize)
序列化内存块。
CFX_SmartPointer::CFX_SmartPointer
CFX_SmartPointer(T *pObj)
构造函数。
Definition: fx_basic.h:3895
CFX_CountRef
Definition: fx_basic.h:3492
CFX_DataFilter::ResetStatistics
void ResetStatistics()
重置统计信息。
CFX_ArrayTemplate
Definition: fx_basic.h:1278
CFX_ArrayTemplate::GetAt
const TYPE GetAt(int nIndex) const
此方法检索由索引号指定的元素。
Definition: fx_basic.h:1377
CFX_ObjectArray::Add
ObjectClass & Add()
向数组添加空对象。
Definition: fx_basic.h:1691
CFX_ArrayTemplate::CFX_ArrayTemplate
CFX_ArrayTemplate(IFX_Allocator *pAllocator=0)
构造函数，从分配器。
Definition: fx_basic.h:1302
FX_LPBYTE
unsigned char * FX_LPBYTE
指向FX_BYTE的指针。
Definition: fx_system.h:667
CFX_BinaryBuf::AppendByte
FX_BOOL AppendByte(FX_BYTE byte)
追加单个字节。
Definition: fx_basic.h:128
CFX_PtrList::Find
FX_POSITION Find(void *searchValue, FX_POSITION startAfter=0) const
从指定位置后开始查找值。
FX_EncodeURI
CFX_ByteString FX_EncodeURI(const CFX_WideString &wsURI)
简单的URI编码。
CFX_SortListArray::Append
void Append(FX_INT32 nStart, FX_INT32 nCount)
追加列表数据。
Definition: fx_basic.h:3985
CFX_CMapDWordToDWord::EstimateSize
void EstimateSize(FX_DWORD size, FX_DWORD grow_by)
更改内部分配大小和增长量。
CFX_CountRef::CountedObj::CountedObj
CountedObj(const CountedObj &src)
拷贝构造函数。
Definition: fx_basic.h:3512
CFX_CMapDWordToDWord::Lookup
FX_BOOL Lookup(FX_DWORD key, FX_DWORD &value) const
通过键查找。
CFX_BinaryBuf::AppendBlock
FX_BOOL AppendBlock(const void *pBuf, FX_STRSIZE size)
追加一个二进制缓冲区块。
CFX_ArrayTemplate::GetData
const TYPE * GetData() const
直接访问元素数据（可能返回NULL）。
Definition: fx_basic.h:1420
CFX_ArrayTemplate::operator=
CFX_ArrayTemplate & operator=(const CFX_ArrayTemplate &src)
赋值运算符重载。
Definition: fx_basic.h:1514
FX_PRIVATEDATA::FreeData
void FreeData()
释放m_pData指向的私有数据。
CFX_ArrayTemplate::operator[]
const TYPE operator[](int nIndex) const
下标([])运算符重载。它检索由nIndex中的基于零的索引指定的元素。
Definition: fx_basic.h:1523
CFX_ByteArray
CFX_ArrayTemplate< FX_BYTE > CFX_ByteArray
字节数组类型的类型定义
Definition: fx_basic.h:1600
IFX_Allocator
Foxit分配器接口。
Definition: fx_memory.h:994
CFX_ByteTextBuf::AppendChar
void AppendChar(int ch)
追加单个字符或字节。
Definition: fx_basic.h:278
CFX_BitStream::SkipBits
void SkipBits(FX_DWORD nBits)
跳过一定数量的位。
Definition: fx_basic.h:3424
CFX_SegmentedArray::CFX_SegmentedArray
CFX_SegmentedArray(int segment_units, int index_size=8, IFX_Allocator *pAllocator=0)
使用指定的段单元数进行构造。
Definition: fx_basic.h:2182
CFX_PtrList::CNode::pPrev
CNode * pPrev
指向前一个节点的指针。
Definition: fx_basic.h:3021
CFX_Stack< CFX_ByteString >::Pop
void Pop()
从栈中弹出字节字符串。
Definition: fx_basic.h:2030
CFX_CharMap
Definition: fx_basic.h:937
CFX_CMapByteStringToPtr::RemoveAll
void RemoveAll()
移除映射中的所有键值对。
CFX_ArrayTemplate::invalidArraySize
无效的数组大小。
Definition: fx_basic.h:1288
CFX_WideTextBuf::GetLength
FX_STRSIZE GetLength() const
获取宽字符文本缓冲区的长度。
Definition: fx_basic.h:442
CFX_SegmentedArray::Add
void Add(ElementType data)
添加一个元素。
Definition: fx_basic.h:2194
FX_FLOAT
float FX_FLOAT
32位浮点数。
Definition: fx_system.h:685
CFX_MapByteStringToPtr::IsEmpty
FX_BOOL IsEmpty() const
验证映射是否为空。
Definition: fx_basic.h:2732
CFX_PtrList::FindIndex
FX_POSITION FindIndex(int index) const
通过索引号查找值。
CFX_CountRef::CFX_CountRef
CFX_CountRef(const Ref &ref)
从另一个引用的拷贝构造函数。
Definition: fx_basic.h:3531
FXSYS_assert
#define FXSYS_assert
断言。
Definition: fx_system.h:804
CFX_ArrayTemplate::AddSpace
TYPE * AddSpace()
添加元素的空间。
Definition: fx_basic.h:1495
CFX_MapByteStringToPtr::CAssoc::pNext
CAssoc * pNext
指向下一个关联的指针。
Definition: fx_basic.h:2700
CFX_ArrayTemplate::GetDataPtr
TYPE * GetDataPtr(int index)
获取指向数组中指定元素的指针。直接指针访问。
Definition: fx_basic.h:1488
IFX_BufferArchive::AppendByte
FX_INT32 AppendByte(FX_BYTE byte)
追加单个字节。
CFX_MapPtrToPtr::GetCount
int GetCount() const
获取元素的数量。
Definition: fx_basic.h:2363
CFX_PtrList::SetAt
void SetAt(FX_POSITION pos, void *newElement)
更改指定位置的值。
Definition: fx_basic.h:3137
CFX_PtrList::AddHead
FX_POSITION AddHead(void *newElement)
向头部添加一个值。
CFX_ArchiveSaver::CFX_ArchiveSaver
CFX_ArchiveSaver(IFX_Allocator *pAllocator=0)
使用分配器构造。
Definition: fx_basic.h:493
CFX_FileBufferArchive::Clear
virtual void Clear()
清除缓冲区。
CFX_BitWriter::WriteBits
void WriteBits(FX_INT64 value, FX_INT32 nBits)
写入位值。
CFX_WideTextBuf::Delete
void Delete(int start_index, int count)
删除宽字符文本缓冲区中由参数 start_index 和 count 定义的区间缓冲区。
Definition: fx_basic.h:459
CFX_ArrayTemplate::SetAt
FX_BOOL SetAt(int nIndex, TYPE newElement)
此方法覆盖由索引号指定的元素。
Definition: fx_basic.h:1393
CFX_ObjectArray::GetSize
int GetSize() const
获取数组的大小。
Definition: fx_basic.h:1788
CFX_Stack< CFX_ByteString >::Top
CFX_ByteString & Top()
获取栈顶的字节字符串。
Definition: fx_basic.h:2020
CFX_BinaryBuf::InsertBlock
FX_BOOL InsertBlock(FX_STRSIZE pos, const void *pBuf, FX_STRSIZE size)
在指定位置插入二进制缓冲区块。
CFX_PtrList::GetAt
void * GetAt(FX_POSITION rPosition) const
获取指定位置的值。
Definition: fx_basic.h:3099
CFX_PtrList::GetTailPosition
FX_POSITION GetTailPosition() const
获取尾部位置。
Definition: fx_basic.h:3048
CFX_Stack::Empty
FX_BOOL Empty() const
清空容器。
Definition: fx_basic.h:1859
CFX_AutoRestorer::~CFX_AutoRestorer
~CFX_AutoRestorer()
析构函数。
Definition: fx_basic.h:3879
CFX_BaseSegmentedArray::~CFX_BaseSegmentedArray
~CFX_BaseSegmentedArray()
析构函数。
CFX_MapPtrTemplate::CFX_MapPtrTemplate
CFX_MapPtrTemplate(IFX_Allocator *pAllocator=0)
默认构造函数。
Definition: fx_basic.h:2546
CFX_UTF8Decoder
Definition: fx_basic.h:992
CFX_ByteTextBuf::GetLength
FX_STRSIZE GetLength() const
获取字节文本缓冲区的长度。
Definition: fx_basic.h:339
CFX_MapPtrTemplate
Definition: fx_basic.h:2538
CFX_BinaryBuf::AppendString
void AppendString(FX_BSTR str)
追加一个非缓冲字节字符串。
Definition: fx_basic.h:119
CFX_Stack< CFX_ByteString >::Empty
FX_BOOL Empty() const
清空容器。
Definition: fx_basic.h:2000
FX_PRIVATEDATA
Definition: fx_basic.h:3237
CFX_TempBuf
Definition: fx_basic.h:2286
CFX_CMapByteStringToPtr::GetNextValue
FX_LPVOID GetNextValue(FX_POSITION &rNextPosition) const
获取当前值并将位置设置为下一个关联。
CFX_ArchiveLoader
Definition: fx_basic.h:641
CFX_CMapByteStringToPtr::GetNextAssoc
void GetNextAssoc(FX_POSITION &rNextPosition, CFX_ByteString &rKey, void *&rValue) const
获取当前关联并将位置设置为下一个关联。
CFX_SortListArray::CFX_SortListArray
CFX_SortListArray(IFX_Allocator *pAllocator=0)
构造函数。
Definition: fx_basic.h:3952
CFX_CMapDWordToDWord::m_Buffer
CFX_BinaryBuf m_Buffer
Definition: fx_basic.h:2684
Failed
失败。
Definition: fx_basic.h:4163
CFX_MapPtrToPtr::CAssoc::key
void * key
键数据。
Definition: fx_basic.h:2337
CFX_WideTextBuf::GetBuffer
FX_LPWSTR GetBuffer() const
获取宽字符指针。
Definition: fx_basic.h:449
CFX_FixedBufGrow::~CFX_FixedBufGrow
~CFX_FixedBufGrow()
析构函数。
Definition: fx_basic.h:2271
Done
完成。
Definition: fx_basic.h:4165
CFX_ArrayTemplate::FX_Error
void FX_Error(ErrorType error, FX_INT32 badIndex=0) const
当引发致命错误时调用此函数。打印错误信息并exit(1)。
Definition: fx_basic.h:1322
CFX_FixedBufGrow::CFX_FixedBufGrow
CFX_FixedBufGrow(int data_size, IFX_Allocator *pAllocator=0)
使用分配器进行构造。
Definition: fx_basic.h:2239
CFX_ByteStringC
常量字节字符串类
Definition: fx_string.h:51
CFX_ArrayTemplate::GetData
TYPE * GetData()
直接访问元素数据（可能返回NULL）。
Definition: fx_basic.h:1427
CFX_ObjectArray
Definition: fx_basic.h:1625
CFX_ByteStringArray
CFX_ObjectArray< CFX_ByteString > CFX_ByteStringArray
CFX_ByteString数组类型的类型定义。
Definition: fx_basic.h:1840
CFX_PrivateData::LookupPrivateData
FX_BOOL LookupPrivateData(FX_LPVOID module_id, FX_LPVOID &pData) const
查找私有数据。
Definition: fx_basic.h:3337
CFX_SmartPointer::~CFX_SmartPointer
~CFX_SmartPointer()
析构函数。
Definition: fx_basic.h:3898
CFX_CountRef::New
ObjClass * New()
创建新对象并引用它。 返回的对象指针可用于修改对象的内容。
Definition: fx_basic.h:3556
CFX_CountRef::CountedObj
在此定义从用户数据类派生的类，带有附加的引用计数成员。
Definition: fx_basic.h:3501
CFX_FloatArray
CFX_ArrayTemplate< FX_FLOAT > CFX_FloatArray
浮点数组的类型定义。
Definition: fx_basic.h:1610
CFX_UTF8Decoder::ClearStatus
void ClearStatus()
清除解码状态。
Definition: fx_basic.h:1034
CFX_SortListArray::~CFX_SortListArray
~CFX_SortListArray()
析构函数。
Definition: fx_basic.h:3955
IFX_BufferArchive::IFX_BufferArchive
IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator *pAllocator=0)
使用缓冲区大小和特殊分配器构造。
CFX_MapPtrToPtr::GetHashTableSize
FX_DWORD GetHashTableSize() const
获取内部哈希表大小。派生类的高级功能。
Definition: fx_basic.h:2452
CFX_MapByteStringToPtr::operator[]
void *& operator[](FX_BSTR key)
下标([])运算符重载。查找，如果不存在则添加。
CFX_CountRef::NotNull
FX_BOOL NotNull() const
检查对象指针是否不为NULL。
Definition: fx_basic.h:3639
CFX_CountRef::GetObjectF
const ObjClass * GetObjectF() const
获取常量对象的指针。此指针不能用于更改对象内容。
Definition: fx_basic.h:3611
CFX_Stack::Top
TYPE & Top()
获取栈顶字节数据。
Definition: fx_basic.h:1879
CFX_MapPtrToPtr::RemoveKey
FX_BOOL RemoveKey(void *key)
移除现有的(键, 值)对。
IFX_BufferArchive::AppendDWord
FX_INT32 AppendDWord(FX_DWORD i)
追加FX_DWORD值。
CFX_MapByteStringToPtr::Lookup
FX_BOOL Lookup(FX_BSTR key, void *&rValue) const
通过键查找。
CFX_CMapByteStringToPtr::SetAt
void SetAt(FX_BSTR key, void *value)
添加新的(键, 值)对。如果不存在则添加，否则修改。
CFX_FixedBufGrow
Definition: fx_basic.h:2216
CFX_BitWriter::CFX_BitWriter
CFX_BitWriter(CFX_BinaryBuf *pBinBuf)
带位写入的构造函数。
Definition: fx_basic.h:3453
CFX_ArrayTemplate::InsertAt
FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray *pNewArray)
在指定位置插入数组。
Definition: fx_basic.h:1581
CFX_FileBufferArchive::~CFX_FileBufferArchive
~CFX_FileBufferArchive()
析构函数。
CFX_ListArrayTemplate::Clear
void Clear()
清空数据。
Definition: fx_basic.h:4095
CFX_BinaryBuf::Delete
void Delete(int start_index, int count)
删除由参数start_index和count定义的二进制缓冲区中的区间缓冲区。
ToBeContinued
待继续。
Definition: fx_basic.h:4157
FX_UrlDecode
CFX_WideString FX_UrlDecode(const CFX_ByteString &bsUrl)
简单的URL解码。
CFX_BitStream::GetBits
FX_DWORD GetBits(FX_DWORD nBits)
获取指定数量的位（最多32位）。
CFX_MapPtrTemplate::operator[]
ValueType & operator[](KeyType key)
下标([])运算符重载。查找，如果不存在则添加。
Definition: fx_basic.h:2572
CFX_ByteString
字节字符串类
Definition: fx_string.h:317
CFX_CMapByteStringToPtr::Lookup
FX_BOOL Lookup(FX_BSTR key, void *&rValue) const
通过键查找。
CFX_PrivateData::SetPrivateData
void SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback)
设置私有数据。
CFX_ByteTextBuf::operator=
void operator=(FX_BSTR str)
赋值(=)运算符重载。从非缓冲字节字符串。
CFX_CMapByteStringToPtr::CFX_CMapByteStringToPtr
CFX_CMapByteStringToPtr(IFX_Allocator *pAllocator=0)
构造函数。
IFX_BufferArchive::~IFX_BufferArchive
virtual ~IFX_BufferArchive()
析构函数。
Definition: fx_basic.h:771
CFX_BasicArray
Definition: fx_basic.h:1157
CFX_BinaryBuf::CopyData
FX_BOOL CopyData(const void *pBuf, FX_STRSIZE size)
从另一个缓冲区复制。
CFX_AutoRestorer::CFX_AutoRestorer
CFX_AutoRestorer(T *location)
构造函数。
Definition: fx_basic.h:3873
FX_LPCBYTE
unsigned char const * FX_LPCBYTE
指向常量FX_BYTE的指针。
Definition: fx_system.h:669
CFX_BinaryBuf::GetBuffer
FX_LPBYTE GetBuffer() const
获取指向二进制缓冲区的字节指针。
Definition: fx_basic.h:196
fx_memory.h
内存管理相关定义和类的头文件。
CFX_FixedBufGrow::SetDataSize
void SetDataSize(int data_size)
使用分配器进行构造。
Definition: fx_basic.h:2257
CFX_MapPtrToPtr::Lookup
FX_BOOL Lookup(void *key, void *&rValue) const
通过键查找。
FX_ProgressiveStatus
FX_ProgressiveStatus
渐进状态的枚举。
Definition: fx_basic.h:4153
CFX_Stack::Pop
void Pop()
从栈中弹出数据。
Definition: fx_basic.h:1889
FX_LPWSTR
wchar_t * FX_LPWSTR
指向Unicode字符的指针。
Definition: fx_system.h:734
CFX_DataFilter::NeedNewSrc
FX_BOOL NeedNewSrc()
指示此过滤器是否需要输入新的源数据。
CFX_ArrayTemplate::InsertAt
FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount=1)
在指定位置插入一个或多个连续元素。
Definition: fx_basic.h:1555
CFX_ArrayTemplate::indexOutOfRange
索引超出范围。
Definition: fx_basic.h:1294
CFX_BaseSegmentedArray::m_pAllocator
IFX_Allocator * m_pAllocator
特殊分配器指针。NULL表示使用默认分配器。
Definition: fx_basic.h:2148
CFX_DataFilter::IsEOF
FX_BOOL IsEOF() const
检测EOF。
Definition: fx_basic.h:3774
CFX_ObjectStack::Push
void Push(const TYPE &val)
将类型对象压入栈中。
Definition: fx_basic.h:1976
CFX_CMapByteStringToPtr::~CFX_CMapByteStringToPtr
~CFX_CMapByteStringToPtr()
析构函数。
CFX_BinaryBuf::TakeOver
void TakeOver(CFX_BinaryBuf &other)
接管另一个缓冲区。
NULL
#define NULL
空指针值。
Definition: fx_system.h:792
CFX_MapPtrToPtr::GetValueAt
void * GetValueAt(void *key) const
通过键获取值指针。
IFX_BufferArchive::AppendInt64
FX_INT32 AppendInt64(FX_INT64 i)
追加FX_INT64值。
CFX_ArchiveLoader::operator >>
CFX_ArchiveLoader & operator >>(FX_BYTE &i)
右移(>>)运算符重载。反序列化字节。
CFX_ArrayTemplate::GetUpperBound
int GetUpperBound() const
获取数组中的上界，实际上是最大有效索引。
Definition: fx_basic.h:1348
CFX_ObjectStack::Size
int Size() const
获取容器的大小。
Definition: fx_basic.h:1944
CFX_CMapByteStringToPtr::RemoveKey
void RemoveKey(FX_BSTR key)
移除现有的(键, ?)对。
CFX_CMapDWordToDWord
Definition: fx_basic.h:2617
CFX_MapPtrToPtr
Definition: fx_basic.h:2326
CFX_BitWriter
Definition: fx_basic.h:3445
CFX_BitStream::IsEOF
FX_BOOL IsEOF() const
检查是否到达流的末尾。
Definition: fx_basic.h:3415
FX_UrlEncode
CFX_ByteString FX_UrlEncode(const CFX_WideString &wsUrl)
简单的URL编码。
CFX_Stack::Push
void Push(const TYPE &val)
将数据压入栈中。
Definition: fx_basic.h:1901
FX_FILESIZE
#define FX_FILESIZE
直接支持大文件。
Definition: fx_stream.h:155
CFX_MapPtrToPtr::GetStartPosition
FX_POSITION GetStartPosition() const
获取第一个键值对位置。用于遍历所有(键, 值)对。
Definition: fx_basic.h:2431
CFX_MapByteStringToPtr
Definition: fx_basic.h:2691
CFX_SortListArray::Clear
void Clear()
清空数据列表。
Definition: fx_basic.h:3965
CFX_CountRef::CountedObj::CountedObj
CountedObj()
构造函数。
Definition: fx_basic.h:3505
CFX_ObjectArray::RemoveAll
void RemoveAll()
移除数组中的所有对象。
Definition: fx_basic.h:1831
CFX_PtrList::GetCount
int GetCount() const
获取节点的数量。
Definition: fx_basic.h:3109
CFX_DataFilter::AbortAll
FX_BOOL AbortAll()
指示是否中止过滤器处理，包括所有目标过滤器。
CFX_CountRef::GetModify
ObjClass * GetModify()
获取对象的可修改副本。
Definition: fx_basic.h:3652
CFX_CMapDWordToDWord::GetNextAssoc
void GetNextAssoc(FX_POSITION &pos, FX_DWORD &key, FX_DWORD &value) const
获取下一个关联。
CFX_MapPtrToPtr::RemoveAll
void RemoveAll()
移除映射中的所有(键, 值)对。
CFX_Stack::Size
int Size() const
获取容器的大小。
Definition: fx_basic.h:1869
FX_Allocator_Free
#define FX_Allocator_Free(fxAllocator, ptr)
在分配器上释放内存块。
Definition: fx_memory.h:1091
CFX_PtrList::GetPrevPosition
FX_POSITION GetPrevPosition(FX_POSITION pos) const
获取前一个位置。
Definition: fx_basic.h:3090
CFX_WideTextBuf::GetWideString
CFX_WideStringC GetWideString() const
从宽字符文本缓冲区获取宽字符串。
CFX_MapPtrToPtr::~CFX_MapPtrToPtr
~CFX_MapPtrToPtr()
析构函数。
CFX_ArchiveLoader::CFX_ArchiveLoader
CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize)
构造加载存档。
FX_PRIVATEDATA::m_pCallback
PD_CALLBACK_FREEDATA m_pCallback
自定义模块提供的用于释放私有数据的回调函数指针。
Definition: fx_basic.h:3253
CFX_BinaryBuf::GetSize
FX_STRSIZE GetSize() const
获取二进制缓冲区的长度。
Definition: fx_basic.h:203
CFX_CharMap::m_GetByteString
CFX_ByteString(* m_GetByteString)(CFX_CharMap *pMap, const CFX_WideString &wstr)
GetByteString函数的指针类型。
Definition: fx_basic.h:976
CFX_BitStream
Definition: fx_basic.h:3381
CFX_CountRef::SetNull
void SetNull()
将对象指针设置为null。
Definition: fx_basic.h:3674
CFX_AutoRestorer
Definition: fx_basic.h:3866
CFX_WCHARArray
CFX_ArrayTemplate< FX_WCHAR > CFX_WCHARArray
FX_WHAR数组的类型定义。
Definition: fx_basic.h:1614
IFX_BufferArchive::AppendString
FX_INT32 AppendString(FX_BSTR lpsz)
追加字节字符串值。
CFX_MapPtrToPtr::InitHashTable
void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow=true)
初始化哈希表。
CFX_CountRef::operator==
FX_BOOL operator==(const Ref &ref) const
比较(==)运算符重载。与另一个引用进行比较。
Definition: fx_basic.h:3690
CFX_ObjectArray::GetDataPtr
ObjectClass * GetDataPtr(int index) const
获取指向数组中指定元素的指针。直接指针访问。
Definition: fx_basic.h:1810
CFX_MapByteStringToPtr::CAssoc::value
void * value
值数据。
Definition: fx_basic.h:2707
FX_INTPTR
INT_PTR FX_INTPTR
指针精度的有符号整型。
Definition: fx_system.h:750
fx_exception.h
异常类的头文件。
FX_BYTE
unsigned char FX_BYTE
字节（8位）。
Definition: fx_system.h:665
CFX_BaseSegmentedArray::GetAt
void * GetAt(int index) const
获取指向元素数据的无类型指针。
CFX_BaseSegmentedArray::RemoveAll
void RemoveAll()
移除数组中的所有元素。
CFX_ObjectStack::Pop
void Pop()
从栈中弹出类型对象。
Definition: fx_basic.h:1964
CFX_FileBufferArchive
Definition: fx_basic.h:858
CFX_CountRef::Decref
void Decref()
减少引用计数。
Definition: fx_basic.h:3721
IFX_Pause::~IFX_Pause
virtual ~IFX_Pause()
析构函数。
Definition: fx_basic.h:3741
CFX_PtrArray
CFX_ArrayTemplate< void * > CFX_PtrArray
无类型指针数组类型的类型定义。
Definition: fx_basic.h:1606
CFX_ArchiveSaver
Definition: fx_basic.h:484
CFX_BaseSegmentedArray::CFX_BaseSegmentedArray
CFX_BaseSegmentedArray(int unit_size=1, int segment_units=512, int index_size=8, IFX_Allocator *pAllocator=0)
使用指定的单元大小、段单元数和索引级别数进行构造。
CFX_ArrayTemplate::Find
int Find(const TYPE &data, int iStart=0) const
从指定位置到最后查找元素。
Definition: fx_basic.h:1590
CFX_UTF8Decoder::Input
void Input(FX_BYTE byte)
输入字节。
fx_system.h
系统相关定义的头文件。
CFX_MapByteStringToPtr::GetNextValue
FX_LPVOID GetNextValue(FX_POSITION &rNextPosition) const
获取当前值并将位置设置为下一个关联。
CFX_BinaryBuf::GetByteString
CFX_ByteStringC GetByteString() const
从缓冲区获取字节字符串。
CFX_ListArrayTemplate::Add
void Add(FX_INT32 nStart, FX_INT32 nCount)
添加列表数据。
Definition: fx_basic.h:4108
CFX_MapPtrToPtr::CAssoc::pNext
CAssoc * pNext
指向下一个关联的指针。
Definition: fx_basic.h:2335