Foxit PDF SDK

fx_basic.h
Go to the documentation of this file.
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 //* Buffer
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 /* Allocation step. */
233 FX_STRSIZE m_AllocStep;
234 /* The buffer pointer. */
235 FX_LPBYTE m_pBuffer;
236 /* The length in bytes of the buffer. */
237 FX_STRSIZE m_DataSize;
238 /* Allocation size in bytes of the buffer. */
239 FX_STRSIZE m_AllocSize;
240 /*
241 * Increase allocated buffer, not data size.
242 *
243 * @param[in] size The size in bytes to increase.
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 //* Archive
477 //*****************************************************************************
485 class CFX_ArchiveSaver : public CFX_Object
486 {
487 public:
494 CFX_ArchiveSaver(IFX_Allocator* pAllocator = NULL) : m_SavingBuf(pAllocator), m_pStream(NULL) {}
495
503 CFX_ArchiveSaver& operator << (FX_BYTE i);
504
512 CFX_ArchiveSaver& operator << (FX_BOOL i);
513
521 CFX_ArchiveSaver& operator << (int i);
522
530 CFX_ArchiveSaver& operator << (FX_DWORD i);
531
539 CFX_ArchiveSaver& operator << (FX_INT64 i);
540
548 CFX_ArchiveSaver& operator << (FX_FLOAT i);
549
557 CFX_ArchiveSaver& operator << (double i);
558
566 CFX_ArchiveSaver& operator << (FX_BSTR bstr);
567
575 CFX_ArchiveSaver& operator << (FX_LPCSTR bstr);
576
584 CFX_ArchiveSaver& operator << (const CFX_ByteString& bstr);
585
595 CFX_ArchiveSaver& operator << (FX_LPCWSTR bstr);
596
606 CFX_ArchiveSaver& operator << (const CFX_WideString& wstr);
607
616 void Write(const void* pData, FX_STRSIZE dwSize);
617
623 FX_INTPTR GetLength() const { return m_SavingBuf.GetSize(); }
624
630 FX_LPCBYTE GetBuffer() const { return m_SavingBuf.GetBuffer(); }
631
639 void SetStream(IFX_FileStream* pStream) { m_pStream = pStream; }
640
641 protected:
642 /* Saving data. */
643 CFX_BinaryBuf m_SavingBuf;
644 /* Stream data. */
645 IFX_FileStream* m_pStream;
646 };
647
651 class CFX_ArchiveLoader : public CFX_Object
652 {
653 public:
662 CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize);
663
671 CFX_ArchiveLoader& operator >> (FX_BYTE& i);
672
680 CFX_ArchiveLoader& operator >> (FX_BOOL& i);
681
689 CFX_ArchiveLoader& operator >> (int& i);
690
698 CFX_ArchiveLoader& operator >> (FX_INT64& i);
699
707 CFX_ArchiveLoader& operator >> (FX_DWORD& i);
708
716 CFX_ArchiveLoader& operator >> (FX_FLOAT& i);
717
725 CFX_ArchiveLoader& operator >> (double& i);
726
734 CFX_ArchiveLoader& operator >> (CFX_ByteString& bstr);
735
743 CFX_ArchiveLoader& operator >> (CFX_WideString& wstr);
744
750 FX_BOOL IsEOF();
751
760 FX_BOOL Read(void* pBuf, FX_DWORD dwSize);
761
762 protected:
763 /* Current loading position. */
764 FX_DWORD m_LoadingPos;
765 /* Loading buffer. */
766 FX_LPCBYTE m_pLoadingBuf;
767 /* The size in bytes of the loading buffer. */
768 FX_DWORD m_LoadingSize;
769 };
770
774 class IFX_BufferArchive
775 {
776 public:
784 IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
785 //<<<+++OPENSOURCE_END
786
790 virtual ~IFX_BufferArchive() {}
791
797 virtual void Clear();
798
804 FX_BOOL Flush();
805
814 FX_INT32 AppendBlock(const void* pBuf, size_t size);
815
823 FX_INT32 AppendByte(FX_BYTE byte);
824
832 FX_INT32 AppendDWord(FX_DWORD i);
833
841 FX_INT32 AppendInt64(FX_INT64 i);
842
850 FX_INT32 AppendString(FX_BSTR lpsz);
851
852 protected:
853 /*
854 * @brief Do work, it will be called when the text buffer is full.
855 *
856 * @param[in] pBuf A pointer to a binary buffer block.
857 * @param[in] size The size in bytes of the buffer block.
858 *
859 * @return <b>true</b> means success, while <b>false</b> means failure.
860 */
861 virtual FX_BOOL DoWork(const void* pBuf, size_t size) = 0;
862
863 /* Special allocator pointer. NULL to use default allocator. */
864 IFX_Allocator* m_pAllocator;
865
866 /* The buffer size*/
867 FX_STRSIZE m_BufSize;
868 /* Buffer. */
869 FX_LPBYTE m_pBuffer;
870 /* Current buffer length. */
871 FX_STRSIZE m_Length;
872 };
873
877 class CFX_FileBufferArchive : public IFX_BufferArchive, public CFX_Object
878 {
879 public:
886 CFX_FileBufferArchive(FX_STRSIZE size = 32768, IFX_Allocator* pAllocator = NULL);
887
891 ~CFX_FileBufferArchive();
892
898 virtual void Clear();
899
905 FX_BOOL Flush();
906
915 FX_BOOL AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover = false);
916
924 FX_BOOL AttachFile(FX_LPCWSTR filename);
925
933 FX_BOOL AttachFile(FX_LPCSTR filename);
934
935 private:
936 /*
937 * Do work, it will be called when the text buffer is full.
938 *
939 * @param[in] pBuf A pointer to a binary buffer block.
940 * @param[in] size The size in bytes of the buffer block.
941 *
942 * @return <b>true</b> means success, while <b>false</b> means failure.
943 */
944 virtual FX_BOOL DoWork(const void* pBuf, size_t size);
945
946 /* The file stream. */
947 IFX_StreamWrite *m_pFile;
948 /* whether take over the file. */
949 FX_BOOL m_bTakeover;
950 };
951
956 struct CFX_CharMap
957 {
968 static CFX_CharMap* GetDefaultMapper(FX_INT32 codepage = 0);
969
982 CFX_WideString (*m_GetWideString)(CFX_CharMap* pMap, const CFX_ByteString& bstr);
983
995 CFX_ByteString (*m_GetByteString)(CFX_CharMap* pMap, const CFX_WideString& wstr);
996
1002 FX_INT32 (*m_GetCodePage)();
1003 };
1004
1005 //*****************************************************************************
1006 //* UTF-8
1007 //*****************************************************************************
1011 class CFX_UTF8Decoder
1012 {
1013 public:
1021 CFX_UTF8Decoder(IFX_Allocator* pAllocator = NULL) : m_PendingBytes(0),m_PendingChar(0),m_Buffer(pAllocator) { }
1022
1028 void Clear();
1029
1037 void Input(FX_BYTE byte);
1038
1046 void AppendChar(FX_DWORD ch);
1047
1053 void ClearStatus() { m_PendingBytes = 0; }
1054
1060 CFX_WideStringC GetResult() const { return m_Buffer.GetWideString(); }
1061
1069 void GetResult(CFX_WideStringL &result) const {m_Buffer.GetWideStringL(result);}
1070
1071 protected:
1072 /* The decoding status. */
1073 int m_PendingBytes;
1074 /* Cached value. */
1075 FX_DWORD m_PendingChar;
1076 /* The output wide text buffer. */
1077 CFX_WideTextBuf m_Buffer;
1078 };
1079
1083 class CFX_UTF8Encoder
1084 {
1085 public:
1091 CFX_UTF8Encoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) { m_UTF16First = 0; }
1092
1100 void Input(FX_WCHAR unicode);
1101
1109 void AppendStr(FX_BSTR str) { m_UTF16First = 0; m_Buffer << str; }
1110
1116 CFX_ByteStringC GetResult() const { return m_Buffer.GetByteString(); }
1117
1125 void GetResult(CFX_ByteStringL &result) const {m_Buffer.GetByteStringL(result);}
1126
1127 protected:
1128 /* The output byte text buffer. */
1129 CFX_ByteTextBuf m_Buffer;
1130 /* The encoding status. */
1131 FX_DWORD m_UTF16First;
1132 };
1133
1141 CFX_ByteString FX_UrlEncode(const CFX_WideString& wsUrl);
1142
1150 CFX_WideString FX_UrlDecode(const CFX_ByteString& bsUrl);
1151
1159 CFX_ByteString FX_EncodeURI(const CFX_WideString& wsURI);
1160
1168 CFX_WideString FX_DecodeURI(const CFX_ByteString& bsURI);
1169
1170 //*****************************************************************************
1171 //* Array
1172 //*****************************************************************************
1176 class CFX_BasicArray : public CFX_Object
1177 {
1178 public:
1180 IFX_Allocator* m_pAllocator;
1181
1182 protected:
1183 /*
1184 * @brief Construct with specified unit size.
1185 *
1186 * @param[in] unit_size The specified unit size. Must be greater than 0 and less than 2^28.
1187 * @param[in] pAllocator Allocator used in this class. <b>NULL</b> means to use default allocator.
1188 * Default value: <b>NULL</b>.
1189 */
1190 CFX_BasicArray(int unit_size, IFX_Allocator* pAllocator = NULL);
1191 //<<<+++OPENSOURCE_END
1192
1193 /*
1194 * @brief The destructor.
1195 */
1196 ~CFX_BasicArray();
1197
1198 /*
1199 * @brief The copy constructor.
1200 *
1201 * @param[in] other The other CFX_BasicArray object.
1202 * @param[in] pAllocator An allocator.
1203 */
1204 CFX_BasicArray(const CFX_BasicArray& other, IFX_Allocator* pAllocator = NULL);
1205
1206 /*
1207 * @brief The assignment operator.
1208 *
1209 * @param[in] other The other CFX_BasicArray object.
1210 *
1211 * @return Reference to current object itself.
1212 */
1213 CFX_BasicArray& operator=(const CFX_BasicArray& other);
1214
1215 /*
1216 * @brief Change the allocated size and the grow amount.
1217 *
1218 * @param[in] nNewSize The new size in elements expected.
1219 * @param[in] nGrowBy The grow amount in elements expected, nGrowBy can be -1 for the grow amount unchanged.
1220 *
1221 * @return <b>true</b> means success, while <b>false</b> means failure (such as parameter or memory error).
1222 */
1223 FX_BOOL SetSize(int nNewSize, int nGrowBy);
1224
1225 /*
1226 * @brief Append a basic array.
1227 *
1228 * @param[in] src The input basic array. It must have the save unit size as the current array.
1229 *
1230 * @return <b>true</b> means success, while <b>false</b> means failure (such as memory error).
1231 */
1232 FX_BOOL Append(const CFX_BasicArray& src);
1233
1234 /*
1235 * @brief Copy from a basic array.
1236 *
1237 * @param[in] src The input basic array. It must have the save unit size as the current array.
1238 *
1239 * @return <b>true</b> means success, while <b>false</b> means failure (such as memory error).
1240 */
1241 FX_BOOL Copy(const CFX_BasicArray& src);
1242
1243 /*
1244 * @brief Insert spaces at specified position.
1245 *
1246 * @param[in] nIndex Specifies the zero-based index of element in the basic array.
1247 * @param[in] nCount Specifies the count of element to insert.
1248 *
1249 * @return A byte pointer to the inserted space. <b>NULL</b> means error.
1250 */
1251 FX_LPBYTE InsertSpaceAt(int nIndex, int nCount);
1252
1253 /*
1254 * @brief Remove a number of elements.
1255 *
1256 * @param[in] nIndex Specifies the zero-based index of start element in the basic array to be removed.
1257 * @param[in] nCount Specifies the count of element to remove.
1258 *
1259 * @return <b>true</b> means success, while <b>false</b> means failure (such as parameter error).
1260 */
1261 FX_BOOL RemoveAt(int nIndex, int nCount);
1262
1263 /*
1264 * @brief Insert a basic array at specified position.
1265 *
1266 * @param[in] nStartIndex Specifies the zero-based index of start element to insert at.
1267 * @param[in] pNewArray The input basic array. It must have the save unit size as the current array.
1268 *
1269 * @return <b>true</b> means success, while <b>false</b> means failure (such as parameter or memory error).
1270 */
1271 FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
1272
1273 /*
1274 * @brief Get a typeless pointer to an element data.
1275 *
1276 * @param[in] index Specifies the zero-based index of element.
1277 *
1278 * @return A typeless pointer to the element data. <b>NULL</b> means error.
1279 */
1280 const void* GetDataPtr(int index) const;
1281
1282 protected:
1283 /* The actual array of data */
1284 FX_LPBYTE m_pData;
1285 /* # of elements (upperBound - 1) */
1286 int m_nSize;
1287 /* Max allocated */
1288 int m_nMaxSize;
1289 /* Grow amount. */
1290 int m_nGrowBy;
1291 /* Number of bytes in one unit. */
1292 int m_nUnitSize;
1293 };
1294
1296 template<class TYPE>
1297 class CFX_ArrayTemplate : public CFX_BasicArray
1298 {
1299 public:
1305 enum ErrorType{
1307 invalidArraySize,
1308
1310 memoryAllocationError,
1311
1313 indexOutOfRange
1314 };
1315
1321 CFX_ArrayTemplate(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(TYPE), pAllocator) {}
1322 //<<<+++OPENSOURCE_END
1323
1330 CFX_ArrayTemplate(const CFX_ArrayTemplate& other, IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(other, pAllocator) {}
1331
1341 void FX_Error(ErrorType error,FX_INT32 badIndex=0) const
1342 {
1343 const char *errorMsg[] = {
1344 "Invalid array size",
1345 "Memory allocation error",
1346 "Invalid index:"
1347 };
1348
1349 fprintf(stderr, "%s\n", errorMsg[error]);
1350 if(error == indexOutOfRange)
1351 fprintf(stderr, "%i\n", badIndex);
1352 abort();
1353 }
1354
1360 int GetSize() const { return m_nSize; }
1361
1367 int GetUpperBound() const { return m_nSize-1; }
1368
1377 FX_BOOL SetSize(int nNewSize, int nGrowBy = -1)
1378 {
1379 return CFX_BasicArray::SetSize(nNewSize, nGrowBy);
1380 }
1381
1387 void RemoveAll() { SetSize(0, -1); }
1388
1396 const TYPE GetAt(int nIndex) const {
1397 if (nIndex < 0 || nIndex >= m_nSize)
1398 //return (const TYPE&)(*(volatile const TYPE*)NULL);
1399 //In order to avoid crash, we input the index.(For reasons unknown)
1400 FX_Error(indexOutOfRange, nIndex);
1401 return ((const TYPE*)m_pData)[nIndex];
1402 }
1403
1412 FX_BOOL SetAt(int nIndex, TYPE newElement) {
1413 if (nIndex < 0 || nIndex >= m_nSize) return false;
1414 ((TYPE*)m_pData)[nIndex] = newElement;
1415 return true;
1416 }
1417
1425 TYPE& ElementAt(int nIndex)
1426 {
1427 if (nIndex < 0 || nIndex >= m_nSize)
1428 //return *(TYPE*)NULL;
1429 //In order to avoid crash, we input the index.(For reasons unknown)
1430 FX_Error(indexOutOfRange, nIndex);
1431 return ((TYPE*)m_pData)[nIndex];
1432 }
1433
1439 const TYPE* GetData() const { return (const TYPE*)m_pData; }
1440
1446 TYPE* GetData() { return (TYPE*)m_pData; }
1447
1456 FX_BOOL SetAtGrow(int nIndex, TYPE newElement)
1457 {
1458 if (nIndex < 0) return false;
1459 if (nIndex >= m_nSize)
1460 if (!SetSize(nIndex+1, -1)) return false;
1461 ((TYPE*)m_pData)[nIndex] = newElement;
1462 return true;
1463 }
1464
1472 FX_BOOL Add(TYPE newElement)
1473 {
1474 if (m_nSize < m_nMaxSize)
1475 m_nSize ++;
1476 else
1477 if (!SetSize(m_nSize+1, -1)) return false;
1478 ((TYPE*)m_pData)[m_nSize-1] = newElement;
1479 return true;
1480 }
1481
1489 FX_BOOL Append(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Append(src); }
1490
1498 FX_BOOL Copy(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Copy(src); }
1499
1507 TYPE* GetDataPtr(int index) { return (TYPE*)CFX_BasicArray::GetDataPtr(index); }
1508
1514 TYPE* AddSpace() { return (TYPE*)CFX_BasicArray::InsertSpaceAt(m_nSize, 1); }
1515
1524 TYPE* InsertSpaceAt(int nIndex, int nCount) { return (TYPE*)CFX_BasicArray::InsertSpaceAt(nIndex, nCount); }
1525
1533 CFX_ArrayTemplate& operator=(const CFX_ArrayTemplate& src) { CFX_BasicArray::operator=(src); return *this; }
1534
1542 const TYPE operator[](int nIndex) const
1543 {
1544 if (nIndex < 0 || nIndex >= m_nSize)
1545 //Merge from google trunk r2049, author: Johnson, date:2012.12.07
1546 *(volatile char*)0 = '\0';
1547 return ((const TYPE*)m_pData)[nIndex];
1548 }
1549
1558 TYPE& operator[](int nIndex)
1559 {
1560 if (nIndex < 0 || nIndex >= m_nSize)
1561 //Merge from google trunk r2049, author: Johnson, date:2012.12.07
1562 *(volatile char*)0 = '\0';
1563 return ((TYPE*)m_pData)[nIndex];
1564 }
1565
1575 FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount = 1)
1576 {
1577 if (!InsertSpaceAt(nIndex, nCount)) return false;
1578 while (nCount--)
1579 ((TYPE*)m_pData)[nIndex++] = newElement;
1580 return true;
1581 }
1582
1591 FX_BOOL RemoveAt(int nIndex, int nCount = 1) { return CFX_BasicArray::RemoveAt(nIndex, nCount); }
1592
1601 FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray) { return CFX_BasicArray::InsertAt(nStartIndex, pNewArray); }
1610 int Find(const TYPE& data, int iStart = 0) const
1611 {
1612 if (iStart < 0) return -1;
1613 for (; iStart < (int)m_nSize; iStart ++)
1614 if (((TYPE*)m_pData)[iStart] == data) return iStart;
1615 return -1;
1616 }
1617 };
1618
1620 typedef CFX_ArrayTemplate<FX_BYTE> CFX_ByteArray;
1622 typedef CFX_ArrayTemplate<FX_WORD> CFX_WordArray;
1624 typedef CFX_ArrayTemplate<FX_DWORD> CFX_DWordArray;
1626 typedef CFX_ArrayTemplate<void*> CFX_PtrArray;
1628 typedef CFX_ArrayTemplate<FX_FILESIZE> CFX_FileSizeArray;
1630 typedef CFX_ArrayTemplate<FX_FLOAT> CFX_FloatArray;
1632 typedef CFX_ArrayTemplate<FX_INT32> CFX_Int32Array;
1634 typedef CFX_ArrayTemplate<FX_WCHAR> CFX_WCHARArray;
1635
1644 template <class ObjectClass>
1645 class CFX_ObjectArray : public CFX_BasicArray
1646 {
1647 public:
1653 CFX_ObjectArray(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(ObjectClass), pAllocator) {}
1654
1658 ~CFX_ObjectArray() { RemoveAll(); }
1659
1666 CFX_ObjectArray(const CFX_ObjectArray& other, IFX_Allocator* pAllocator = NULL)
1667 : CFX_BasicArray(sizeof(ObjectClass), pAllocator)
1668 {
1669 Copy(other);
1670 }
1671
1679 CFX_ObjectArray& operator=(const CFX_ObjectArray& other)
1680 {
1681 Copy(other);
1682 return *this;
1683 }
1684
1694 void Add(const ObjectClass& data)
1695 {
1696 #ifndef _FX_NOPLACEMENTNEW_
1697 new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
1698 #else
1699 ::new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
1700 #endif
1701
1702 }
1703
1711 ObjectClass& Add()
1712 {
1713 #ifndef _FX_NOPLACEMENTNEW_
1714 return *(ObjectClass*) new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
1715 #else
1716 return *(ObjectClass*) ::new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
1717 #endif
1718 }
1719
1727 void* AddSpace()
1728 {
1729 return InsertSpaceAt(m_nSize, 1);
1730 }
1731
1742 FX_INT32 Append(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
1743 {
1744 if (nCount == 0) return 0;
1745 FX_INT32 nSize = src.GetSize();
1746 if (!nSize) return 0;
1747 FXSYS_assert(nStart > -1 && nStart < nSize);
1748 if (nCount < 0) nCount = nSize;
1749 if (nStart + nCount > nSize) nCount = nSize - nStart;
1750 if (nCount < 1) return 0;
1751 nSize = m_nSize;
1752 InsertSpaceAt(m_nSize, nCount);
1753 ObjectClass* pStartObj = (ObjectClass*)GetDataPtr(nSize);
1754 nSize = nStart + nCount;
1755 for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++)
1756 {
1757 #ifndef _FX_NOPLACEMENTNEW_
1758 new ((void*)pStartObj) ObjectClass(src[i]);
1759 #else
1760 ::new ((void*)pStartObj) ObjectClass(src[i]);
1761 #endif
1762
1763 }
1764 return nCount;
1765 }
1766
1777 FX_INT32 Copy(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
1778 {
1779 if (this == &src) return 0;
1780 RemoveAll();
1781 if (nCount == 0) return 0;
1782 FX_INT32 nSize = src.GetSize();
1783 if (!nSize) return 0;
1784 FXSYS_assert(nStart > -1 && nStart < nSize);
1785 if (nCount < 0) nCount = nSize;
1786 if (nStart + nCount > nSize) nCount = nSize - nStart;
1787 if (nCount < 1) return 0;
1788 nSize = nStart + nCount;
1789 SetSize(nCount, -1);
1790 ObjectClass* pStartObj = (ObjectClass*)m_pData;
1791 for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++)
1792 {
1793 #ifndef _FX_NOPLACEMENTNEW_
1794 new ((void*)pStartObj) ObjectClass(src[i]);
1795 #else
1796 ::new ((void*)pStartObj) ObjectClass(src[i]);
1797 #endif
1798
1799 }
1800 return nCount;
1801 }
1802
1808 int GetSize() const {return m_nSize;}
1809
1818 ObjectClass& operator[] (int index) const
1819 {
1820 FXSYS_assert(index < m_nSize);
1821 return *(ObjectClass*)CFX_BasicArray::GetDataPtr(index);
1822 }
1823
1831 ObjectClass* GetDataPtr(int index) const {return (ObjectClass*)CFX_BasicArray::GetDataPtr(index);}
1832
1840 void RemoveAt(int index)
1841 {
1842 FXSYS_assert(index < m_nSize);
1843 ((ObjectClass*)GetDataPtr(index))->~ObjectClass();
1844 CFX_BasicArray::RemoveAt(index, 1);
1845 }
1846
1852 void RemoveAll()
1853 {
1854 for (int i = 0; i < m_nSize; i ++)
1855 ((ObjectClass*)GetDataPtr(i))->~ObjectClass();
1856 CFX_BasicArray::SetSize(0, -1);
1857 }
1858 };
1859
1861 typedef CFX_ObjectArray<CFX_ByteString> CFX_ByteStringArray;
1863 typedef CFX_ObjectArray<CFX_WideString> CFX_WideStringArray;
1864
1868 template <class TYPE>
1869 class CFX_Stack : CFX_Object
1870 {
1871 public:
1873 CFX_Stack() {}
1874
1880 FX_BOOL Empty() const
1881 {
1882 return m_Container.GetSize() == 0;
1883 }
1884
1890 int Size() const
1891 {
1892 return m_Container.GetSize();
1893 }
1894
1900 TYPE& Top()
1901 {
1902 return m_Container[Size() - 1];
1903 }
1904
1910 void Pop()
1911 {
1912 m_Container.RemoveAt(Size() - 1);
1913 }
1914
1922 void Push(const TYPE& val)
1923 {
1924 m_Container.Add(val);
1925 }
1926
1932 void Clear()
1933 {
1934 m_Container.RemoveAll();
1935 }
1936 private:
1937 CFX_ArrayTemplate<TYPE> m_Container;
1938 };
1939
1943 template <class TYPE>
1944 class CFX_ObjectStack : CFX_Object
1945 {
1946 public:
1948 CFX_ObjectStack() {}
1949
1955 FX_BOOL Empty() const
1956 {
1957 return m_Container.GetSize() == 0;
1958 }
1959
1965 int Size() const
1966 {
1967 return m_Container.GetSize();
1968 }
1969
1975 TYPE& Top()
1976 {
1977 return m_Container[Size() - 1];
1978 }
1979
1985 void Pop()
1986 {
1987 m_Container.RemoveAt(Size() - 1);
1988 }
1989
1997 void Push(const TYPE& val)
1998 {
1999 m_Container.Add(val);
2000 }
2001
2002 private:
2003 CFX_ObjectArray<TYPE> m_Container;
2004 };
2005
2009 template <>
2010 class CFX_Stack<CFX_ByteString> : CFX_Object
2011 {
2012 public:
2014 CFX_Stack() {}
2015
2021 FX_BOOL Empty() const
2022 {
2023 return m_Container.GetSize() == 0;
2024 }
2025
2031 int Size() const
2032 {
2033 return m_Container.GetSize();
2034 }
2035
2041 CFX_ByteString& Top()
2042 {
2043 return m_Container[Size() - 1];
2044 }
2045
2051 void Pop()
2052 {
2053 m_Container.RemoveAt(Size() - 1);
2054 }
2055
2063 void Push(const CFX_ByteString& val)
2064 {
2065 m_Container.Add(val);
2066 }
2067
2068 private:
2069 CFX_ObjectArray<CFX_ByteString> m_Container;
2070 };
2071
2075 class CFX_BaseSegmentedArray : public CFX_Object
2076 {
2077 public:
2086 CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8, IFX_Allocator* pAllocator = NULL);
2087
2091 ~CFX_BaseSegmentedArray();
2092
2102 void SetUnitSize(int unit_size, int segment_units, int index_size = 8);
2103
2109 void* Add();
2110
2118 void* GetAt(int index) const;
2119
2125 void RemoveAll();
2126
2135 void Delete(int index, int count = 1);
2136
2142 int GetSize() const { return m_DataSize; }
2143
2149 int GetSegmentSize() const { return m_SegmentSize; }
2150
2156 int GetUnitSize() const { return m_UnitSize; }
2157
2166 void* Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2167
2169 IFX_Allocator* m_pAllocator;
2170 private:
2171 /* Unit size */
2172 int m_UnitSize;
2173 /* Count of units in each segment. */
2174 short m_SegmentSize;
2175 /* Number of index level in the array. */
2176 FX_BYTE m_IndexSize;
2177 /* The current level in the index tree. */
2178 FX_BYTE m_IndexDepth;
2179 /* The current number of units in the array. */
2180 int m_DataSize;
2181 /* index to segments or indices, or directly pointing to the segment if only one segment. */
2182 void* m_pIndex;
2183
2184 void** GetIndex(int seg_index) const;
2185 void* IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2186 void* IterateSegment(FX_LPCBYTE pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2187 };
2188
2192 template <class ElementType>
2193 class CFX_SegmentedArray : public CFX_BaseSegmentedArray
2194 {
2195 public:
2203 CFX_SegmentedArray(int segment_units, int index_size = 8, IFX_Allocator* pAllocator = NULL)
2204 : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size, pAllocator)
2205 {}
2206 //<<<+++OPENSOURCE_END
2207
2215 void Add(ElementType data)
2216 {
2217 *(ElementType*)CFX_BaseSegmentedArray::Add() = data;
2218 }
2219
2227 ElementType& operator [] (int index)
2228 {
2229 return *(ElementType*)CFX_BaseSegmentedArray::GetAt(index);
2230 }
2231 };
2232
2236 template <class DataType, int FixedSize>
2237 class CFX_FixedBufGrow : public CFX_Object
2238 {
2239 public:
2246 CFX_FixedBufGrow(IFX_Allocator* pAllocator = NULL)
2247 : m_pAllocator(pAllocator)
2248 , m_pData(NULL)
2249 {
2250 FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2251 }
2252
2260 CFX_FixedBufGrow(int data_size, IFX_Allocator* pAllocator = NULL)
2261 : m_pAllocator(pAllocator)
2262 , m_pData(NULL)
2263 {
2264 if (data_size > FixedSize)
2265 m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
2266 else
2267 FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2268 }
2269 //<<<+++OPENSOURCE_END
2270
2278 void SetDataSize(int data_size) {
2279 if (m_pData)
2280 FX_Allocator_Free(m_pAllocator, m_pData);
2281 m_pData = NULL;
2282 if (data_size > FixedSize)
2283 m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
2284 else {
2285 FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2286 }
2287 }
2288
2292 ~CFX_FixedBufGrow() { if (m_pData) FX_Allocator_Free(m_pAllocator, m_pData); }
2293
2294 operator DataType*() { return m_pData ? m_pData : m_Data; }
2295
2296 private:
2297 IFX_Allocator* m_pAllocator;
2298
2299 DataType m_Data[FixedSize];
2300 DataType* m_pData;
2301 };
2302
2306 template <class DataType>
2307 class CFX_TempBuf
2308 {
2309 public:
2317 CFX_TempBuf(int size, IFX_Allocator* pAllocator = NULL) : m_pAllocator(pAllocator)
2318 {
2319 m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, size);
2320 }
2321
2325 ~CFX_TempBuf()
2326 {
2327 if (m_pData) FX_Allocator_Free(m_pAllocator, m_pData);
2328 }
2329 //<<<+++OPENSOURCE_END
2330
2331 DataType& operator[](int i) { FXSYS_assert(m_pData != NULL); return m_pData[i]; }
2332 operator DataType*() const { return m_pData; }
2333
2334 private:
2335 IFX_Allocator* m_pAllocator;
2336
2337 DataType* m_pData;
2338 };
2339
2340 //*****************************************************************************
2341 //* Map
2342 //*****************************************************************************
2343
2347 class CFX_MapPtrToPtr : public CFX_Object
2348 {
2349 protected:
2353 struct CAssoc
2354 {
2356 CAssoc* pNext;
2358 void* key;
2360 void* value;
2361 };
2362
2363 public:
2371 CFX_MapPtrToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
2372 //<<<+++OPENSOURCE_END
2373
2377 ~CFX_MapPtrToPtr();
2378
2384 int GetCount() const { return m_nCount; }
2385
2391 FX_BOOL IsEmpty() const { return m_nCount == 0; }
2392
2401 FX_BOOL Lookup(void* key, void*& rValue) const;
2402
2410 void* GetValueAt(void* key) const;
2411
2419 void*& operator[](void* key);
2420
2429 void SetAt(void* key, void* newValue) { (*this)[key] = newValue; }
2430
2438 FX_BOOL RemoveKey(void* key);
2439
2445 void RemoveAll();
2446
2452 FX_POSITION GetStartPosition() const { return (m_nCount == 0) ? NULL : (FX_POSITION)-1; }
2453
2466 void GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void*& rValue) const;
2467
2473 FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
2474
2484 void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = true);
2485
2486 protected:
2487 /* Special allocator pointer. NULL to use default allocator. */
2488 IFX_Allocator* m_pAllocator;
2489
2490 /* The hash table. */
2491 CAssoc** m_pHashTable;
2492 /* The size of hash table. */
2493 FX_DWORD m_nHashTableSize;
2494 /* The number of key-value pair in the map. */
2495 int m_nCount;
2496 /* The freed association list internal. */
2497 CAssoc* m_pFreeList;
2498 /* The block list internal. */
2499 struct CFX_Plex* m_pBlocks;
2500 /* The size in associations of each block. */
2501 int m_nBlockSize;
2502
2503 /*
2504 * Routine used to user-provided hash keys.
2505 *
2506 * @note Overwrite-able: special non-virtual (see map implementation for details).
2507 *
2508 * @param[in] key The key used to produce hash key.
2509 * @return A hash value.
2510 */
2511 FX_DWORD HashKey(void* key) const;
2512
2513 /*
2514 * Allocate a new association.
2515 *
2516 * @return The pointer to the new allocated association.
2517 */
2518 CAssoc* NewAssoc();
2519 /*
2520 * Free an association.
2521 *
2522 * @param[in] pAssoc A pointer to an association.
2523 */
2524 void FreeAssoc(CAssoc* pAssoc);
2525 /*
2526 * @brief Retrieve an association by a key.
2527 *
2528 * @param[in] key The input key.
2529 * @param[out] hash The hash value computed.
2530 *
2531 * @return Current association object.
2532 */
2533 CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
2534 /*
2535 * @brief Retrieve current association by position.
2536 *
2537 * @param[in, out] rNextPosition Input a position, and receive the next association position.
2538 *
2539 * @return Current association object.
2540 */
2541 CAssoc* GetCurrentAssoc(FX_POSITION& rNextPosition) const;
2542 /*
2543 * @brief Expand 2 times HashTable Size than before.
2544 *
2545 * @details The MaxHashTableSize is 10000.
2546 *
2547 * @return <b>true</b> means success, while <b>false</b> means failure.
2548 */
2549 FX_BOOL ExpandHashTable();
2550 private:
2551 CFX_MapPtrToPtr(const CFX_MapPtrToPtr &) FX_EQDELETE;
2552 CFX_MapPtrToPtr &operator=(const CFX_MapPtrToPtr &) FX_EQDELETE;
2553 };
2554
2558 template <class KeyType, class ValueType>
2559 class CFX_MapPtrTemplate : public CFX_MapPtrToPtr
2560 {
2561 public:
2567 CFX_MapPtrTemplate(IFX_Allocator* pAllocator = NULL) : CFX_MapPtrToPtr(10, pAllocator) {}
2568
2577 FX_BOOL Lookup(KeyType key, ValueType& rValue) const
2578 {
2579 FX_LPVOID pValue = NULL;
2580 if (!CFX_MapPtrToPtr::Lookup((void*)(FX_UINTPTR)key, pValue))
2581 return false;
2582 rValue = (ValueType)(FX_UINTPTR)pValue;
2583 return true;
2584 }
2585
2593 ValueType& operator[](KeyType key) { return (ValueType&)CFX_MapPtrToPtr::operator []((void*)(FX_UINTPTR)key); }
2594
2603 void SetAt(KeyType key, ValueType newValue) { CFX_MapPtrToPtr::SetAt((void*)(FX_UINTPTR)key, (void*)(FX_UINTPTR)newValue); }
2604
2612 FX_BOOL RemoveKey(KeyType key) { return CFX_MapPtrToPtr::RemoveKey((void*)(FX_UINTPTR)key); }
2613
2623 void GetNextAssoc(FX_POSITION& rNextPosition, KeyType& rKey, ValueType& rValue) const
2624 {
2625 void* pKey = NULL; void* pValue = NULL;
2626 CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
2627 rKey = (KeyType)(FX_UINTPTR)pKey; rValue = (ValueType)(FX_UINTPTR)pValue;
2628 }
2629 private:
2630 CFX_MapPtrTemplate(const CFX_MapPtrTemplate &) FX_EQDELETE;
2631 CFX_MapPtrTemplate &operator=(const CFX_MapPtrTemplate &) FX_EQDELETE;
2632 };
2633
2638 class CFX_CMapDWordToDWord : public CFX_Object
2639 {
2640 public:
2646 CFX_CMapDWordToDWord(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) {}
2647
2656 FX_BOOL Lookup(FX_DWORD key, FX_DWORD& value) const;
2657
2666 void SetAt(FX_DWORD key, FX_DWORD value);
2667
2676 void EstimateSize(FX_DWORD size, FX_DWORD grow_by);
2677
2683 FX_POSITION GetStartPosition() const;
2684
2694 void GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;
2695
2701 void RemoveAll() { m_Buffer.Clear(); }
2702
2703 protected:
2705 CFX_BinaryBuf m_Buffer;
2706 private:
2707 CFX_CMapDWordToDWord(const CFX_CMapDWordToDWord &) FX_EQDELETE;
2708 CFX_CMapDWordToDWord &operator=(const CFX_CMapDWordToDWord &) FX_EQDELETE;
2709 };
2710
2712 class CFX_MapByteStringToPtr : public CFX_Object
2713 {
2714 protected:
2718 struct CAssoc
2719 {
2721 CAssoc* pNext;
2722
2724 FX_DWORD nHashValue;
2726 CFX_ByteString key;
2728 void* value;
2729 };
2730
2731 public:
2739 CFX_MapByteStringToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
2740
2746 int GetCount() const { return m_nCount; }
2747
2753 FX_BOOL IsEmpty() const { return m_nCount == 0; }
2754
2763 FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;
2764
2772 void*& operator[](FX_BSTR key);
2773
2782 void SetAt(FX_BSTR key, void* newValue) { (*this)[key] = newValue; }
2783
2791 FX_BOOL RemoveKey(FX_BSTR key);
2792
2798 void RemoveAll();
2799
2805 FX_POSITION GetStartPosition() const { return (m_nCount == 0) ? NULL : (FX_POSITION)-1; }
2806
2816 void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
2817
2825 FX_LPVOID GetNextValue(FX_POSITION& rNextPosition) const;
2826
2832 FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
2833
2843 void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = true);
2844
2854 FX_DWORD HashKey(FX_BSTR key) const;
2855
2856 protected:
2857 /* Special allocator pointer. NULL to use default allocator. */
2858 IFX_Allocator* m_pAllocator;
2859
2860 /* The hash table. */
2861 CAssoc** m_pHashTable;
2862 /* The size of hash table. */
2863 FX_DWORD m_nHashTableSize;
2864 /* The number of key-value pair in the map. */
2865 int m_nCount;
2866 /* The freed association list internal. */
2867 CAssoc* m_pFreeList;
2868 /* The block list internal. */
2869 struct CFX_Plex* m_pBlocks;
2870 /* The size in associations of each block. */
2871 int m_nBlockSize;
2872
2873 /*
2874 * @brief Allocate a new association.
2875 *
2876 * @return The pointer to the new allocated association.
2877 */
2878 CAssoc* NewAssoc();
2879 /*
2880 * @brief Free an association.
2881 *
2882 * @param[in] pAssoc A pointer to an association.
2883 *
2884 * @return None.
2885 */
2886 void FreeAssoc(CAssoc* pAssoc);
2887 /*
2888 * @brief Retrieve an association by a key.
2889 *
2890 * @param[in] key The input key.
2891 * @param[out] hash The hash value computed.
2892 *
2893 * @return An association object.
2894 */
2895 CAssoc* GetAssocAt(FX_BSTR key, FX_DWORD& hash) const;
2896 /*
2897 * @brief Retrieve current association by position.
2898 *
2899 * @param[in] rNextPosition The current position.
2900 *
2901 * @return An association object.
2902 */
2903 CAssoc* GetCurrentAssoc(FX_POSITION& rNextPosition) const;
2904 /*
2905 * @brief Expand 2 times HashTable Size than before.
2906 *
2907 * @details The MaxHashTableSize is 10000.
2908 *
2909 * @return <b>true</b> means success, while <b>false</b> means failure.
2910 */
2911 FX_BOOL ExpendHashTable();
2912
2913 public:
2915 ~CFX_MapByteStringToPtr();
2916 };
2917
2926 class CFX_CMapByteStringToPtr : public CFX_Object
2927 {
2928 public:
2934 CFX_CMapByteStringToPtr(IFX_Allocator* pAllocator = NULL);
2935 //<<<+++OPENSOURCE_END
2936
2938 ~CFX_CMapByteStringToPtr();
2939
2945 void RemoveAll();
2946
2952 FX_POSITION GetStartPosition() const;
2953
2963 void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
2964
2972 FX_LPVOID GetNextValue(FX_POSITION& rNextPosition) const;
2973
2982 FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;
2983
2992 void SetAt(FX_BSTR key, void* value);
2993
3001 void RemoveKey(FX_BSTR key);
3002
3008 int GetCount() const;
3009
3021 void AddValue(FX_BSTR key, void* pValue);
3022
3023 protected:
3024 /* A chained buffer storing keys and values. */
3025 CFX_BaseSegmentedArray m_Buffer;
3026 };
3027
3029 // Lists
3031
3033 class CFX_PtrList : public CFX_Object
3034 {
3035 protected:
3037 struct CNode
3038 {
3040 CNode* pNext;
3042 CNode* pPrev;
3044 void* data;
3045 };
3046
3047 public:
3054 CFX_PtrList(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
3055 //<<<+++OPENSOURCE_END
3056
3062 FX_POSITION GetHeadPosition() const { return (FX_POSITION)m_pNodeHead; }
3063
3069 FX_POSITION GetTailPosition() const { return (FX_POSITION)m_pNodeTail; }
3070
3078 void* GetNext(FX_POSITION& rPosition) const
3079 {
3080 CNode* pNode = (CNode*)rPosition; rPosition = (FX_POSITION)pNode->pNext; return pNode->data;
3081 }
3082
3090 void* GetPrev(FX_POSITION& rPosition) const
3091 {
3092 CNode* pNode = (CNode*)rPosition; rPosition = (FX_POSITION)pNode->pPrev; return pNode->data;
3093 }
3094
3102 FX_POSITION GetNextPosition(FX_POSITION pos) const { return ((CNode*)pos)->pNext; }
3103
3111 FX_POSITION GetPrevPosition(FX_POSITION pos) const { return ((CNode*)pos)->pPrev; }
3112
3120 void* GetAt(FX_POSITION rPosition) const
3121 {
3122 CNode* pNode = (CNode*)rPosition; return pNode ? pNode->data : NULL;
3123 }
3124
3130 int GetCount() const { return m_nCount; }
3131
3139 FX_POSITION AddTail(void* newElement);
3140
3148 FX_POSITION AddHead(void* newElement);
3149
3158 void SetAt(FX_POSITION pos, void* newElement)
3159 {
3160 CNode* pNode = (CNode*)pos; pNode->data = newElement;
3161 }
3162
3171 FX_POSITION InsertAfter(FX_POSITION pos, void* newElement);
3172
3181 FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL ) const;
3182
3190 FX_POSITION FindIndex(int index) const;
3191
3199 void RemoveAt(FX_POSITION pos);
3200
3206 void RemoveAll();
3207
3208 protected:
3209 /* Special allocator pointer. <b>NULL</b> means to use default allocator. */
3210 IFX_Allocator* m_pAllocator;
3211
3212 /* Pointer to the head. */
3213 CNode* m_pNodeHead;
3214 /* Pointer to the tail. */
3215 CNode* m_pNodeTail;
3216 /* The count of nodes in the list. */
3217 int m_nCount;
3218 /* The freed node list internal. */
3219 CNode* m_pNodeFree;
3220 /* The block list internal. */
3221 struct CFX_Plex* m_pBlocks;
3222 /* The size in nodes of each block. */
3223 int m_nBlockSize;
3224
3225 /*
3226 * Allocate a new node.
3227 *
3228 * @param[in] pPrev The pointer to the previous node.
3229 * @param[in] pNext The pointer to the next node.
3230 *
3231 * @return The pointer to the new node.
3232 */
3233 CNode* NewNode(CNode* pPrev, CNode* pNext);
3234 /*
3235 * Free a node.
3236 *
3237 * @param[in] pNode The node pointer.
3238 */
3239 void FreeNode(CNode* pNode);
3240
3241 public:
3243 ~CFX_PtrList();
3244 };
3245
3246 //*****************************************************************************
3247 //* Utilities
3248 //*****************************************************************************
3249
3253 typedef void (*PD_CALLBACK_FREEDATA)(FX_LPVOID pData);
3254
3258 struct FX_PRIVATEDATA
3259 {
3265 void FreeData();
3266
3268 FX_LPVOID m_pModuleId;
3269
3271 FX_LPVOID m_pData;
3272
3274 PD_CALLBACK_FREEDATA m_pCallback;
3275
3280 FX_BOOL m_bSelfDestruct;
3281 };
3282
3286 class CFX_PrivateData
3287 {
3288 public:
3294 CFX_PrivateData(IFX_Allocator* pAllocator = NULL) : m_DataList(pAllocator) {}
3295
3297 ~CFX_PrivateData();
3298
3304 void ClearAll();
3305
3322 void SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback);
3323
3336 void SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject* pObj);
3337
3348 FX_LPVOID GetPrivateData(FX_LPVOID module_id);
3349
3358 FX_BOOL LookupPrivateData(FX_LPVOID module_id, FX_LPVOID &pData) const
3359 {
3360 if (!module_id) return false;
3361 FX_DWORD nCount = m_DataList.GetSize();
3362 for (FX_DWORD n = 0; n < nCount; n++) {
3363 if (m_DataList[n].m_pModuleId == module_id) {
3364 pData = m_DataList[n].m_pData;
3365 return true;
3366 }
3367 }
3368 return false;
3369 }
3370
3380 FX_BOOL RemovePrivateData(FX_LPVOID module_id);
3381
3382 protected:
3383 /* Private data array. */
3384 CFX_ArrayTemplate<FX_PRIVATEDATA> m_DataList;
3385 /*
3386 * Add a private data. Add if not exist, otherwise modify.
3387 *
3388 * @param[in] module_id The module id.
3389 * @param[in] pData The private data.
3390 * @param[in] callback The callback function for deallocating provided private data.
3391 * @param[in] bSelfDestruct Whether the private data is a CFX_DestructObject derived object actually.
3392 *
3393 * @return None.
3394 */
3395 void AddData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct);
3396 };
3397
3402 class CFX_BitStream : public CFX_Object
3403 {
3404 public:
3413 void Init(FX_LPCBYTE pData, FX_DWORD dwSize);
3414
3422 FX_DWORD GetBits(FX_DWORD nBits);
3423
3429 void ByteAlign();
3430
3436 FX_BOOL IsEOF() const { return m_BitPos >= m_BitSize; }
3437
3445 void SkipBits(FX_DWORD nBits) { m_BitPos += nBits; }
3446
3452 void Rewind() { m_BitPos = 0; }
3453
3454 protected:
3455 /* Bit position (zero-based). */
3456 FX_DWORD m_BitPos;
3457 /* Total bit counts in the memory block. */
3458 FX_DWORD m_BitSize;
3459 /* bit-stream stream buffer. */
3460 FX_LPCBYTE m_pData;
3461 };
3462
3466 class CFX_BitWriter : public CFX_Object
3467 {
3468 public:
3474 CFX_BitWriter(CFX_BinaryBuf* pBinBuf) :m_pBinBuf(pBinBuf), m_BitPos(0), m_BytePos(0) {}
3475
3484 void WriteBits(FX_INT64 value, FX_INT32 nBits);
3485
3491 void ByteAlign();
3492
3498 int GetCurBytePos() { return m_BytePos; }
3499
3500 protected:
3501 /* Dynamic binary buffer. */
3502 CFX_BinaryBuf * m_pBinBuf;
3503 /* Bit position (zero-based). */
3504 int m_BitPos;
3505 /* Byte position (zero-based). */
3506 int m_BytePos;
3507 };
3508
3513 template <class ObjClass> class CFX_CountRef : public CFX_Object
3514 {
3515 public:
3517 typedef CFX_CountRef<ObjClass> Ref;
3518
3522 class CountedObj : public ObjClass
3523 {
3524 public:
3526 CountedObj():m_RefCount(0) {}
3527
3533 CountedObj(const CountedObj& src) : ObjClass(src) ,m_RefCount(0){}
3534
3536 int m_RefCount;
3537 };
3538
3542 CFX_CountRef()
3543 {
3544 m_pObject = NULL;
3545 }
3546
3552 CFX_CountRef(const Ref& ref)
3553 {
3554 m_pObject = ref.m_pObject;
3555 if (m_pObject) m_pObject->m_RefCount ++;
3556 }
3557
3561 ~CFX_CountRef()
3562 {
3563 if (!m_pObject) return;
3564 m_pObject->m_RefCount --;
3565 if (m_pObject->m_RefCount <= 0) {
3566 delete m_pObject;
3567 m_pObject = NULL;
3568 }
3569 }
3570
3577 ObjClass* New()
3578 {
3579 if (m_pObject) {
3580 m_pObject->m_RefCount --;
3581 if (m_pObject->m_RefCount <= 0)
3582 delete m_pObject;
3583 m_pObject = NULL;
3584 }
3585 m_pObject = FX_NEW CountedObj;
3586 if (!m_pObject) return NULL;
3587 m_pObject->m_RefCount = 1;
3588 return m_pObject;
3589 }
3590
3598 void operator = (const Ref& ref)
3599 {
3600 if (ref.m_pObject)
3601 ref.m_pObject->m_RefCount ++;
3602 if (m_pObject) {
3603 m_pObject->m_RefCount --;
3604 if (m_pObject->m_RefCount <= 0)
3605 delete m_pObject;
3606 }
3607 m_pObject = ref.m_pObject;
3608 }
3609
3617 void operator = (void* p)
3618 {
3619 FXSYS_assert(p == 0);
3620 if (m_pObject == NULL) return;
3621 m_pObject->m_RefCount --;
3622 if (m_pObject->m_RefCount <= 0)
3623 delete m_pObject;
3624 m_pObject = NULL;
3625 }
3626
3632 const ObjClass* GetObjectF() const
3633 {
3634 return m_pObject;
3635 }
3641 operator const ObjClass*() const
3642 {
3643 return m_pObject;
3644 }
3645
3651 FX_BOOL IsNull() const
3652 {
3653 return m_pObject == NULL;
3654 }
3660 FX_BOOL NotNull() const
3661 {
3662 return m_pObject != NULL;
3663 }
3664
3673 ObjClass* GetModify()
3674 {
3675 if (m_pObject == NULL) {
3676 m_pObject = FX_NEW CountedObj;
3677 if (m_pObject)
3678 m_pObject->m_RefCount = 1;
3679 } else if (m_pObject->m_RefCount > 1) {
3680 m_pObject->m_RefCount --;
3681 CountedObj* pOldObject = m_pObject;
3682 m_pObject = NULL;
3683 m_pObject = FX_NEW CountedObj(*pOldObject);
3684 if (m_pObject)
3685 m_pObject->m_RefCount = 1;
3686 }
3687 return m_pObject;
3688 }
3689
3695 void SetNull()
3696 {
3697 if (m_pObject == NULL) return;
3698 m_pObject->m_RefCount --;
3699 if (m_pObject->m_RefCount <= 0)
3700 delete m_pObject;
3701 m_pObject = NULL;
3702 }
3703
3711 FX_BOOL operator == (const Ref& ref) const
3712 {
3713 return m_pObject == ref.m_pObject;
3714 }
3715
3721 int RefCount() const
3722 {
3723 return m_pObject ? m_pObject->m_RefCount : 0;
3724 }
3725
3731 void Incref()
3732 {
3733 if (m_pObject == NULL) return;
3734 m_pObject->m_RefCount++;
3735 }
3736
3742 void Decref()
3743 {
3744 if (m_pObject == NULL) return;
3745 m_pObject->m_RefCount--;
3746 if (m_pObject->m_RefCount <= 0) {
3747 delete m_pObject;
3748 m_pObject = NULL;
3749 }
3750 }
3751
3752 protected:
3753 /* Reference counted object internal. */
3754 CountedObj* m_pObject;
3755 };
3756
3758 class IFX_Pause
3759 {
3760 public:
3762 virtual ~IFX_Pause() {}
3763
3769 virtual FX_BOOL NeedToPauseNow() = 0;
3770 };
3771
3773 class CFX_DataFilter : public CFX_Object
3774 {
3775 public:
3779 virtual ~CFX_DataFilter();
3780
3788 void SetDestFilter(CFX_DataFilter* pFilter);
3789
3795 FX_BOOL IsEOF() const { return m_bEOF; }
3796
3802 FX_FILESIZE GetSrcPos() const { return m_SrcPos; }
3803
3813 void FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf& dest_buf);
3814
3823 void FilterFinish(CFX_BinaryBuf& dest_buf);
3824
3830 FX_BOOL IsExhaustBuffer() const { return m_bExhaustBuffer; }
3831
3837 FX_BOOL NeedNewSrc();
3838
3844 FX_BOOL Abort() const { return m_bAbort; }
3845
3851 FX_BOOL AbortAll();
3852
3858 void ResetStatistics();
3859
3860 protected:
3861 /* The constructor. */
3862 CFX_DataFilter();
3863
3864 virtual void v_FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf& dest_buf) = 0;
3865 virtual void v_FilterFinish(CFX_BinaryBuf& dest_buf) = 0;
3866 virtual void v_ResetStatistics() {};
3867 void ReportEOF(FX_FILESIZE left_input);
3868
3869 /* Current position in the source stream. */
3870 FX_FILESIZE m_SrcPos;
3871
3872 /* Store the output data of the FilterIn function.*/
3873 CFX_BinaryBuf m_FilterInBuffer;
3874
3875 /* Indicate whether this filter aborts the filter process. For instance, RunLenFilter meets bad input data */
3876 FX_BOOL m_bAbort;
3877 /* Indicate whether we met the EOF. */
3878 FX_BOOL m_bEOF;
3879 /* Indicate whether this filter exhausts the input buffer. */
3880 FX_BOOL m_bExhaustBuffer;
3881 /* Filter chain. */
3882 CFX_DataFilter* m_pDestFilter;
3883 };
3884
3886 template<typename T>
3887 class CFX_AutoRestorer {
3888 public:
3894 explicit CFX_AutoRestorer(T* location) {
3895 m_Location = location;
3896 m_OldValue = *location;
3897 }
3898
3900 ~CFX_AutoRestorer() { *m_Location = m_OldValue; }
3901 private:
3902 T* m_Location;
3903 T m_OldValue;
3904 };
3905
3907 template <class T>
3908 class CFX_SmartPointer
3909 {
3910 public:
3916 CFX_SmartPointer(T *pObj) : m_pObj(pObj) {}
3917
3919 ~CFX_SmartPointer() {m_pObj->Release();}
3920
3926 T* Get(void) {return m_pObj;}
3927
3933 T& operator *(void) {return *m_pObj;}
3934
3940 T* operator ->(void) {return m_pObj;}
3941
3942 protected:
3943 T *m_pObj;
3944 };
3945
3946 #define FX_DATALIST_LENGTH 1024
3947
3949 template<size_t unit>
3950 class CFX_SortListArray : public CFX_Object
3951 {
3952 protected:
3954 struct DataList {
3956 FX_INT32 start;
3958 FX_INT32 count;
3959 FX_LPBYTE data;
3960 DataList()
3961 {
3962 start = count = 0;
3963 data = NULL;
3964 }
3965 };
3966
3967 public:
3973 CFX_SortListArray(IFX_Allocator* pAllocator = NULL) : m_CurList(0), m_DataLists(pAllocator) {}
3974
3976 ~CFX_SortListArray()
3977 {
3978 Clear();
3979 }
3980
3986 void Clear()
3987 {
3988 IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
3989
3990 for (FX_INT32 i = m_DataLists.GetUpperBound(); i >= 0; i--){
3991 DataList list = m_DataLists.ElementAt(i);
3992 if (list.data) FX_Allocator_Free(pAllocator, list.data);
3993 }
3994 m_DataLists.RemoveAll();
3995 m_CurList = 0;
3996 }
3997
4006 void Append(FX_INT32 nStart, FX_INT32 nCount)
4007 {
4008 if (nStart < 0) return;
4009
4010 IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
4011
4012 while (nCount > 0){
4013 FX_INT32 temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
4014 DataList list;
4015
4016 list.data = FX_Allocator_Alloc(pAllocator, FX_BYTE, temp_count * unit);
4017 if (!list.data) break;
4018 FXSYS_memset32(list.data, 0, temp_count * unit);
4019 list.start = nStart;
4020 list.count = temp_count;
4021
4022 FX_BOOL ret = Append(list);
4023 if(ret)
4024 {
4025 nCount -= temp_count;
4026 nStart += temp_count;
4027 }
4028 else
4029 {
4030 if (list.data) FX_Allocator_Free(pAllocator, list.data);
4031 return;
4032 }
4033 }
4034 }
4035
4043 FX_LPBYTE GetAt(FX_INT32 nIndex)
4044 {
4045 if (nIndex < 0) return NULL;
4046 if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) return NULL;
4047 DataList *pCurList = m_DataLists.GetDataPtr(m_CurList);
4048 if (!pCurList || nIndex < pCurList->start || nIndex >= pCurList->start + pCurList->count){
4049 pCurList = NULL;
4050 FX_INT32 iStart = 0;
4051 FX_INT32 iEnd = m_DataLists.GetUpperBound();
4052 while (iStart <= iEnd){
4053 FX_INT32 iMid = (iStart + iEnd) / 2;
4054 DataList* list = m_DataLists.GetDataPtr(iMid);
4055 if (nIndex < list->start)
4056 iEnd = iMid - 1;
4057 else if (nIndex >= list->start + list->count)
4058 iStart = iMid + 1;
4059 else {
4060 pCurList = list;
4061 m_CurList = iMid;
4062 break;
4063 }
4064 }
4065 }
4066 return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;
4067 }
4068
4069 protected:
4070 FX_BOOL Append(const DataList& list)
4071 {
4072 FX_INT32 iStart = 0;
4073 FX_INT32 iEnd = m_DataLists.GetUpperBound();
4074 FX_INT32 iFind = 0;
4075 while (iStart <= iEnd) {
4076 FX_INT32 iMid = (iStart + iEnd) / 2;
4077 DataList* cur_list = m_DataLists.GetDataPtr(iMid);
4078 if (list.start == cur_list->start){
4079 return false; // lists overlap, no op
4080 } else if (list.start < cur_list->start + cur_list->count)
4081 iEnd = iMid - 1;
4082 else{
4083 if (iMid == iEnd){
4084 iFind = iMid + 1;
4085 break;
4086 }
4087 DataList* next_list = m_DataLists.GetDataPtr(iMid + 1);
4088 if (list.start == next_list->start){
4089 return false; // lists overlap, no op
4090 } else if (list.start < next_list->start){
4091 iFind = iMid + 1;
4092 break;
4093 } else {
4094 iStart = iMid + 1;
4095 }
4096 }
4097 }
4098 m_DataLists.InsertAt(iFind, list);
4099 return true;
4100 }
4101
4102 FX_INT32 m_CurList;
4103 CFX_ArrayTemplate<DataList> m_DataLists;
4104 };
4105
4107 template<typename T1, typename T2>
4108 class CFX_ListArrayTemplate : public CFX_Object
4109 {
4110 public:
4116 void Clear()
4117 {
4118 m_Data.Clear();
4119 }
4120
4129 void Add(FX_INT32 nStart, FX_INT32 nCount)
4130 {
4131 m_Data.Append(nStart, nCount);
4132 }
4133
4141 T2& operator [] (FX_INT32 nIndex)
4142 {
4143 FX_LPBYTE data = m_Data.GetAt(nIndex);
4144 FXSYS_assert(data != NULL);
4145
4146 return (T2&)(*(volatile T2*)data);
4147 }
4148
4156 T2* GetPtrAt(FX_INT32 nIndex)
4157 {
4158 return (T2*)m_Data.GetAt(nIndex);
4159 }
4160 protected:
4161 T1 m_Data;
4162 };
4163
4165 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_FILESIZE)>, FX_FILESIZE> CFX_FileSizeListArray;
4167 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_DWORD)>, FX_DWORD> CFX_DWordListArray;
4168
4174 typedef enum {
4176 Ready,
4178 ToBeContinued,
4180 Found,
4182 NotFound,
4184 Failed,
4186 Done
4187 } FX_ProgressiveStatus;
4188
4189 #define ProgressiveStatus FX_ProgressiveStatus
4190
4191 #ifdef _FX_NO_NAMESPACE_
4192 //<<<+++OPENSOURCE_BEGIN LIC==FOXIT
4193 #define FX_NAMESPACE_DECLARE(namespace, type) type
4194 //<<<+++OPENSOURCE_END
4195 #else
4196 //<<<+++OPENSOURCE_BEGIN LIC==GOOGLE
4197 #define FX_NAMESPACE_DECLARE(namespace, type) namespace::type
4198 //<<<+++OPENSOURCE_END
4199 #endif
4200
4202 class IFX_Unknown
4203 {
4204 public:
4210 virtual FX_DWORD Release() = 0;
4211
4217 virtual FX_DWORD AddRef() = 0;
4218
4219 protected:
4220 virtual ~IFX_Unknown() {}
4221 };
4222
4224 #define FX_IsOdd(a) ((a) & 1)
4225
4226 //<<<+++OPENSOURCE_MUST_END
4227
4228 //<<<+++OPENSOURCE_MUST_BEGIN
4229 #endif // _FX_BASIC_H_
4230 //<<<+++OPENSOURCE_MUST_END
4231
4234 //<<<+++OPENSOURCE_END
CFX_DataFilter
Definition: fx_basic.h:3773
CFX_MapByteStringToPtr::GetNextAssoc
void GetNextAssoc(FX_POSITION &rNextPosition, CFX_ByteString &rKey, void *&rValue) const
Get the current association and set the position to next association.
CFX_MapByteStringToPtr::SetAt
void SetAt(FX_BSTR key, void *newValue)
Add a new (key, value) pair. Add if not exist, otherwise modify.
Definition: fx_basic.h:2782
CFX_CMapByteStringToPtr::GetStartPosition
FX_POSITION GetStartPosition() const
Get the first key-value pair position. iterating all (key, value) pairs.
CFX_PrivateData
Definition: fx_basic.h:3286
CFX_WideTextBuf::operator<<
CFX_WideTextBuf & operator<<(int i)
Left shifts(<<) operator overload. Output a integer to the wide text buffer.
CFX_PtrList::CNode::pNext
CNode * pNext
Pointer to next node.
Definition: fx_basic.h:3040
CFX_UTF8Decoder::GetResult
CFX_WideStringC GetResult() const
Get the result.
Definition: fx_basic.h:1060
FX_LPVOID
void * FX_LPVOID
Pointer to any type.
Definition: fx_system.h:654
CFX_MapByteStringToPtr::RemoveAll
void RemoveAll()
Remove all the (key, value) pairs in the map.
CFX_BinaryBuf
Dynamic binary buffers designed for more efficient appending.
Definition: fx_basic.h:52
CFX_BaseSegmentedArray
Definition: fx_basic.h:2075
IFX_Unknown
Definition: fx_basic.h:4202
Ready
Ready.
Definition: fx_basic.h:4176
CFX_MapByteStringToPtr::~CFX_MapByteStringToPtr
~CFX_MapByteStringToPtr()
The destructor.
CFX_ListArrayTemplate::operator []
T2 & operator [](FX_INT32 nIndex)
Subscript([]) operator overload.
Definition: fx_basic.h:4141
CFX_ObjectArray::Add
void Add(const ObjectClass &data)
Add a copy of an existing object to the array.
Definition: fx_basic.h:1694
fx_stream.h
Header file for Streams related definitions and classes.
FX_WCHAR
wchar_t FX_WCHAR
Compiler dependant Unicode character (16-bit for Microsoft Compiler, 32-bit for gcc).
Definition: fx_system.h:732
CFX_PtrList::CNode
Bidirectional node in CFX_PtrList.
Definition: fx_basic.h:3037
FX_PRIVATEDATA::m_pModuleId
FX_LPVOID m_pModuleId
Module ID.
Definition: fx_basic.h:3268
CFX_UTF8Encoder::GetResult
CFX_ByteStringC GetResult() const
Get the result.
Definition: fx_basic.h:1116
CFX_ArrayTemplate::operator[]
TYPE & operator[](int nIndex)
Subscript([]) operator overload. This function returns a reference to the specified element specified...
Definition: fx_basic.h:1558
FX_DWORD
unsigned long FX_DWORD
32-bit unsigned integer.
Definition: fx_system.h:726
CFX_UTF8Encoder
Definition: fx_basic.h:1083
CFX_PrivateData::RemovePrivateData
FX_BOOL RemovePrivateData(FX_LPVOID module_id)
Remove previously stored private data. FPDFAPI assumes the module has deallocated the data,...
CFX_WideTextBuf::AppendChar
FX_BOOL AppendChar(FX_WCHAR wch)
Append a single wide character.
CFX_Stack< CFX_ByteString >::Size
int Size() const
Get size of the container.
Definition: fx_basic.h:2031
CFX_MapPtrToPtr::IsEmpty
FX_BOOL IsEmpty() const
Verify whether the map is empty.
Definition: fx_basic.h:2391
CFX_PtrList::InsertAfter
FX_POSITION InsertAfter(FX_POSITION pos, void *newElement)
Insert a value after specified position.
CFX_WideStringC
CONSTANT WIDE STRING CLASS.
Definition: fx_string.h:1214
NotFound
Not Found.
Definition: fx_basic.h:4182
CFX_MapByteStringToPtr::CAssoc
Association in CFX_MapByteStringToPtr.
Definition: fx_basic.h:2718
CFX_BasicArray::m_pAllocator
IFX_Allocator * m_pAllocator
Special allocator pointer. NULL to use default allocator.
Definition: fx_basic.h:1180
CFX_CountRef::Incref
void Incref()
Increase the reference.
Definition: fx_basic.h:3731
CFX_BaseSegmentedArray::Delete
void Delete(int index, int count=1)
Delete a number of elements.
CFX_Stack
Definition: fx_basic.h:1869
CFX_ObjectArray::~CFX_ObjectArray
~CFX_ObjectArray()
The destructor.
Definition: fx_basic.h:1658
CFX_MapPtrToPtr::GetNextAssoc
void GetNextAssoc(FX_POSITION &rNextPosition, void *&rKey, void *&rValue) const
Get the current association and set the position to next association.
FX_Allocator_Alloc
#define FX_Allocator_Alloc(fxAllocator, type, size)
Release-mode allocation on an allocator.
Definition: fx_memory.h:1087
CFX_ByteStringC::GetLength
FX_STRSIZE GetLength() const
Get the length of the byte string.
Definition: fx_string.h:227
CFX_DWordArray
CFX_ArrayTemplate< FX_DWORD > CFX_DWordArray
Type definition for a double-word array type.
Definition: fx_basic.h:1624
CFX_ArrayTemplate::ElementAt
TYPE & ElementAt(int nIndex)
This method retrieves a ref to an element specified by an index number.
Definition: fx_basic.h:1425
CFX_ObjectArray::CFX_ObjectArray
CFX_ObjectArray(const CFX_ObjectArray &other, IFX_Allocator *pAllocator=0)
The copy constructor.
Definition: fx_basic.h:1666
CFX_CMapByteStringToPtr::AddValue
void AddValue(FX_BSTR key, void *pValue)
Add a key-value pair to the dictionary, assuming there is no duplicated key existing.
CFX_ListArrayTemplate::GetPtrAt
T2 * GetPtrAt(FX_INT32 nIndex)
Get a point to data.
Definition: fx_basic.h:4156
CFX_Stack< CFX_ByteString >::Push
void Push(const CFX_ByteString &val)
Push the byte string to stack.
Definition: fx_basic.h:2063
CFX_WordArray
CFX_ArrayTemplate< FX_WORD > CFX_WordArray
Type definition for a word array type.
Definition: fx_basic.h:1622
CFX_PtrList::RemoveAll
void RemoveAll()
Remove all nodes in the list.
CFX_CMapByteStringToPtr::GetCount
int GetCount() const
Get the number of key-value pairs.
CFX_ByteTextBuf::operator<<
CFX_ByteTextBuf & operator<<(int i)
Left shifts(<<) operator overload. Output an integer to the byte text buffer.
CFX_CountRef::IsNull
FX_BOOL IsNull() const
Check if the pointer of the object is NULL.
Definition: fx_basic.h:3651
CFX_SegmentedArray::operator []
ElementType & operator [](int index)
Subscript([]) operator overload. This function returns a ref to the specified element specified by th...
Definition: fx_basic.h:2227
CFX_FixedBufGrow::CFX_FixedBufGrow
CFX_FixedBufGrow(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:2246
CFX_PtrList::CNode::data
void * data
Node data.
Definition: fx_basic.h:3044
CFX_CMapDWordToDWord::SetAt
void SetAt(FX_DWORD key, FX_DWORD value)
Add a new (key, value) pair. Add if not exist, otherwise modify.
CFX_CharMap::GetDefaultMapper
static CFX_CharMap * GetDefaultMapper(FX_INT32 codepage=0)
Get a character mapper according to Windows code page or other encoding system. This char maps are ma...
CFX_ObjectStack::Empty
FX_BOOL Empty() const
Empty the container.
Definition: fx_basic.h:1955
CFX_BitStream::Init
void Init(FX_LPCBYTE pData, FX_DWORD dwSize)
Initialize the bit-stream with a memory block. Must call Init() first.
CFX_MapByteStringToPtr::CAssoc::key
CFX_ByteString key
Key data.
Definition: fx_basic.h:2726
CFX_MapPtrTemplate::SetAt
void SetAt(KeyType key, ValueType newValue)
Add a new (key, value) pair. Add if not exist, otherwise modify.
Definition: fx_basic.h:2603
CFX_MapByteStringToPtr::GetStartPosition
FX_POSITION GetStartPosition() const
Get the first key-value pair position. iterating all (key, value) pairs.
Definition: fx_basic.h:2805
CFX_CharMap::m_GetCodePage
FX_INT32(* m_GetCodePage)()
A pointer type to GetCodePage function. The function return a code page of the platform.
Definition: fx_basic.h:1002
CFX_BinaryBuf::GetByteStringL
void GetByteStringL(CFX_ByteStringL &str) const
Get a byte string from current buffer object.
CFX_BinaryBuf::CFX_BinaryBuf
CFX_BinaryBuf(IFX_Allocator *pAllocator=0)
A default constructor creating an empty buffer.
CFX_MapPtrToPtr::SetAt
void SetAt(void *key, void *newValue)
Add a new (key, value) pair. Add if not exist, otherwise modify.
Definition: fx_basic.h:2429
PD_CALLBACK_FREEDATA
void(* PD_CALLBACK_FREEDATA)(FX_LPVOID pData)
Definition: fx_basic.h:3253
FX_LPCWSTR
wchar_t const * FX_LPCWSTR
Pointer to constant Unicode characters.
Definition: fx_system.h:736
CFX_ObjectArray::operator=
CFX_ObjectArray & operator=(const CFX_ObjectArray &other)
The assignment operator.
Definition: fx_basic.h:1679
FX_PRIVATEDATA::m_bSelfDestruct
FX_BOOL m_bSelfDestruct
A boolean value to decide whether it is using self destruct for private data. If this is true,...
Definition: fx_basic.h:3280
CFX_BaseSegmentedArray::Add
void * Add()
Add an element.
FX_PRIVATEDATA::m_pData
FX_LPVOID m_pData
Private data.
Definition: fx_basic.h:3271
CFX_WideTextBuf::CFX_WideTextBuf
CFX_WideTextBuf(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:354
IFX_BufferArchive::Flush
FX_BOOL Flush()
Flush internal buffer of the file.
CFX_DataFilter::FilterFinish
void FilterFinish(CFX_BinaryBuf &dest_buf)
Indicate the input finished. For some filters, there might be some last output generated.
CFX_SortListArray::DataList::start
FX_INT32 start
The start index.
Definition: fx_basic.h:3956
CFX_Stack< CFX_ByteString >::CFX_Stack
CFX_Stack()
Construct.
Definition: fx_basic.h:2014
CFX_CountRef::~CFX_CountRef
~CFX_CountRef()
Destruct a reference and release the object it refers to.
Definition: fx_basic.h:3561
CFX_ObjectArray::RemoveAt
void RemoveAt(int index)
Remove an object at specified position.
Definition: fx_basic.h:1840
CFX_BaseSegmentedArray::GetSize
int GetSize() const
Get number of elements in the array.
Definition: fx_basic.h:2142
CFX_BitWriter::GetCurBytePos
int GetCurBytePos()
Get current byte position.
Definition: fx_basic.h:3498
CFX_PtrList::CFX_PtrList
CFX_PtrList(int nBlockSize=10, IFX_Allocator *pAllocator=0)
Construct with block size and allocator.
CFX_UTF8Decoder::Clear
void Clear()
Clear the decoding status and set the output wide text buffer to be empty.
CFX_DataFilter::~CFX_DataFilter
virtual ~CFX_DataFilter()
The destructor. Destroy this filter and all its chain.
CFX_BitStream::ByteAlign
void ByteAlign()
Get to byte boundary. If current bit position is not multiplication of 8, the rest of the current byt...
CFX_BaseSegmentedArray::SetUnitSize
void SetUnitSize(int unit_size, int segment_units, int index_size=8)
Change the unit size and the segment units. This can only be called when array is empty.
CFX_DataFilter::FilterIn
void FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf &dest_buf)
Input a data block to the filter (and its filter chain), and receive the final output.
CFX_PrivateData::ClearAll
void ClearAll()
Release all remaining data.
CFX_ArrayTemplate::GetSize
int GetSize() const
Get the number of elements in the array.
Definition: fx_basic.h:1360
CFX_FileBufferArchive::Flush
FX_BOOL Flush()
Flush internal buffer.
CFX_BinaryBuf::EstimateSize
FX_BOOL EstimateSize(FX_STRSIZE size, FX_STRSIZE alloc_step=0)
Change the allocated buffer size, and set the allocation step if alloc_step is non-zero.
CFX_PtrList::GetNextPosition
FX_POSITION GetNextPosition(FX_POSITION pos) const
Get the next position.
Definition: fx_basic.h:3102
CFX_SmartPointer::operator *
T & operator *(void)
Get the object reference operator.
Definition: fx_basic.h:3933
IFX_BufferArchive
Definition: fx_basic.h:774
CFX_PrivateData::GetPrivateData
FX_LPVOID GetPrivateData(FX_LPVOID module_id)
Get previously stored private data. Returns NULL for not stored.
CFX_ObjectArray::Copy
FX_INT32 Copy(const CFX_ObjectArray &src, FX_INT32 nStart=0, FX_INT32 nCount=-1)
Copy from an array.
Definition: fx_basic.h:1777
CFX_SegmentedArray
Definition: fx_basic.h:2193
CFX_UTF8Encoder::CFX_UTF8Encoder
CFX_UTF8Encoder(IFX_Allocator *pAllocator=0)
A constructor. Set the encoder to initial.
Definition: fx_basic.h:1091
CFX_ArchiveSaver::SetStream
void SetStream(IFX_FileStream *pStream)
Set the attached stream.
Definition: fx_basic.h:639
CFX_WideTextBuf::operator=
void operator=(FX_LPCWSTR lpsz)
Assignment(=) operator overload. From a zero terminated wide character string.
CFX_TempBuf::CFX_TempBuf
CFX_TempBuf(int size, IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:2317
FX_MIN
#define FX_MIN(a, b)
A macro that returns the minimum of a and b.
Definition: fx_system.h:826
CFX_DataFilter::Abort
FX_BOOL Abort() const
Indicate whether to abort the filter process.
Definition: fx_basic.h:3844
CFX_FileBufferArchive::AttachFile
FX_BOOL AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover=false)
Attach file.
CFX_UTF8Encoder::GetResult
void GetResult(CFX_ByteStringL &result) const
Get the result.
Definition: fx_basic.h:1125
CFX_CMapDWordToDWord::CFX_CMapDWordToDWord
CFX_CMapDWordToDWord(IFX_Allocator *pAllocator=0)
Constructor with allocator.
Definition: fx_basic.h:2646
CFX_BaseSegmentedArray::GetUnitSize
int GetUnitSize() const
Get number of bytes for each element.
Definition: fx_basic.h:2156
CFX_ObjectStack
Definition: fx_basic.h:1944
CFX_WideString
WIDE STRING CLASS.
Definition: fx_string.h:1461
CFX_BinaryBuf::AppendFill
FX_BOOL AppendFill(FX_BYTE byte, FX_STRSIZE count)
Append a byte for specified number times. Not a byte-by-byte processing, but a byte filling processin...
CFX_UTF8Decoder::CFX_UTF8Decoder
CFX_UTF8Decoder(IFX_Allocator *pAllocator=0)
A constructor. Set the decoder to initial.
Definition: fx_basic.h:1021
CFX_CountRef::Ref
CFX_CountRef< ObjClass > Ref
Type definition: it is used short for CFX_CountRef<ObjClass>.
Definition: fx_basic.h:3517
CFX_ObjectArray::CFX_ObjectArray
CFX_ObjectArray(IFX_Allocator *pAllocator=0)
The constructor.
Definition: fx_basic.h:1653
IFX_StreamWrite
Stream writing interface.
Definition: fx_stream.h:441
CFX_Stack::CFX_Stack
CFX_Stack()
Construct.
Definition: fx_basic.h:1873
IFX_Unknown::AddRef
virtual FX_DWORD AddRef()=0
Increments reference count.
CFX_MapByteStringToPtr::CFX_MapByteStringToPtr
CFX_MapByteStringToPtr(int nBlockSize=10, IFX_Allocator *pAllocator=0)
Construct with specified block size.
FX_POSITION
void * FX_POSITION
A value used to denote the position of an element in a collection.
Definition: fx_system.h:658
CFX_PrivateData::CFX_PrivateData
CFX_PrivateData(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:3294
IFX_Unknown::Release
virtual FX_DWORD Release()=0
Decrements reference count and release the current object.
CFX_PtrList::~CFX_PtrList
~CFX_PtrList()
CFX_BaseSegmentedArray::GetSegmentSize
int GetSegmentSize() const
Get number of elements in each segment.
Definition: fx_basic.h:2149
CFX_UTF8Encoder::Input
void Input(FX_WCHAR unicode)
Input a unicode.
CFX_ArchiveSaver::GetLength
FX_INTPTR GetLength() const
Get the length of saved data.
Definition: fx_basic.h:623
CFX_ArrayTemplate::memoryAllocationError
Memory allocation error.
Definition: fx_basic.h:1310
CFX_ArchiveSaver::GetBuffer
FX_LPCBYTE GetBuffer() const
Get the constant byte pointer to the saved data.
Definition: fx_basic.h:630
CFX_ArchiveLoader::Read
FX_BOOL Read(void *pBuf, FX_DWORD dwSize)
De-serialize a memory block.
IFX_Pause::NeedToPauseNow
virtual FX_BOOL NeedToPauseNow()=0
Check whether callers need to pause now.
CFX_MapByteStringToPtr::InitHashTable
void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow=true)
Initialize the hash table.
CFX_ObjectArray::operator[]
ObjectClass & operator[](int index) const
Subscript([]) operator overload. This function returns a reference to the specified object specified ...
Definition: fx_basic.h:1818
CFX_ArrayTemplate::Copy
FX_BOOL Copy(const CFX_ArrayTemplate &src)
Copy from an array.
Definition: fx_basic.h:1498
CFX_ArrayTemplate::SetSize
FX_BOOL SetSize(int nNewSize, int nGrowBy=-1)
Change the allocated size and the grow amount.
Definition: fx_basic.h:1377
CFX_ByteStringC::GetPtr
FX_LPCBYTE GetPtr() const
Get a constant byte string pointer to the byte string.
Definition: fx_string.h:215
CFX_BinaryBuf::Clear
void Clear()
Set the binary buffer to be empty.
CFX_PrivateData::SetPrivateObj
void SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject *pObj)
Set private object.
CFX_WideTextBuf
Definition: fx_basic.h:345
CFX_Stack::Clear
void Clear()
Remove all remaining data from stack.
Definition: fx_basic.h:1932
CFX_MapByteStringToPtr::HashKey
FX_DWORD HashKey(FX_BSTR key) const
Routine used to user-provided hash keys.
CFX_BinaryBuf::m_pAllocator
IFX_Allocator * m_pAllocator
Special allocator pointer. NULL means to use default allocator.
Definition: fx_basic.h:229
FX_INT64
__int64 FX_INT64
Signed 64-bit integer.
Definition: fx_system.h:740
CFX_CountRef::CountedObj::m_RefCount
int m_RefCount
The reference count.
Definition: fx_basic.h:3536
CFX_SmartPointer
Definition: fx_basic.h:3908
CFX_FileBufferArchive::CFX_FileBufferArchive
CFX_FileBufferArchive(FX_STRSIZE size=32768, IFX_Allocator *pAllocator=0)
A constructor with size and allocator.
fx_string.h
Header file for Strings, variable-length sequence of characters. There are two strings here,...
CFX_MapPtrToPtr::CAssoc::value
void * value
Value data.
Definition: fx_basic.h:2360
CFX_MapPtrToPtr::CFX_MapPtrToPtr
CFX_MapPtrToPtr(int nBlockSize=10, IFX_Allocator *pAllocator=0)
Construct with specified block size.
CFX_DataFilter::GetSrcPos
FX_INT64 GetSrcPos() const
Get current position in the source stream (byte offset from the beginning of all input data).
Definition: fx_basic.h:3802
CFX_ArrayTemplate::Append
FX_BOOL Append(const CFX_ArrayTemplate &src)
Append an array.
Definition: fx_basic.h:1489
CFX_MapPtrTemplate::RemoveKey
FX_BOOL RemoveKey(KeyType key)
Remove existing (key, ?) pair.
Definition: fx_basic.h:2612
CFX_SmartPointer::operator ->
T * operator ->(void)
Get the object pointer operator.
Definition: fx_basic.h:3940
FX_INT32
int FX_INT32
32-bit signed integer.
Definition: fx_system.h:683
CFX_MapPtrTemplate::Lookup
FX_BOOL Lookup(KeyType key, ValueType &rValue) const
Lookup by a key.
Definition: fx_basic.h:2577
FXSYS_memset32
void * FXSYS_memset32(void *dst, FX_INT32 v, size_t size)
Set buffer data to specified value.
CFX_CountRef::CFX_CountRef
CFX_CountRef()
Construct a null reference.
Definition: fx_basic.h:3542
FX_STRSIZE
int FX_STRSIZE
String size is limited to 2^31-1.
Definition: fx_string.h:35
CFX_ArrayTemplate::RemoveAll
void RemoveAll()
Clean up the array.
Definition: fx_basic.h:1387
CFX_PtrList::GetHeadPosition
FX_POSITION GetHeadPosition() const
Get the header position.
Definition: fx_basic.h:3062
CFX_CMapDWordToDWord::GetStartPosition
FX_POSITION GetStartPosition() const
Get the first key-value pair position. iterating all (key, value) pairs.
CFX_ArrayTemplate::Add
FX_BOOL Add(TYPE newElement)
Add an element at the tail. Potentially growing the array.
Definition: fx_basic.h:1472
CFX_Int32Array
CFX_ArrayTemplate< FX_INT32 > CFX_Int32Array
Type definition for INT32 array.
Definition: fx_basic.h:1632
CFX_CMapByteStringToPtr
Definition: fx_basic.h:2926
CFX_ByteTextBuf
Definition: fx_basic.h:251
CFX_ArchiveLoader::IsEOF
FX_BOOL IsEOF()
Check whether de-serializing is to the end of the loading buffer.
CFX_ByteTextBuf::CFX_ByteTextBuf
CFX_ByteTextBuf(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:260
CFX_MapPtrToPtr::CAssoc
Association in CFX_MapPtrToPtr.
Definition: fx_basic.h:2353
CFX_MapByteStringToPtr::GetCount
int GetCount() const
Get the number of elements.
Definition: fx_basic.h:2746
CFX_PrivateData::~CFX_PrivateData
~CFX_PrivateData()
The destructor.
CFX_BinaryBuf::~CFX_BinaryBuf
~CFX_BinaryBuf()
The destructor.
CFX_BaseSegmentedArray::Iterate
void * Iterate(FX_BOOL(*callback)(void *param, void *pData), void *param) const
Iterate all units, with a callback function for each unit.
FX_BOOL
int FX_BOOL
Boolean variable (should be TRUE or FALSE).
Definition: fx_system.h:691
CFX_ArrayTemplate< FX_PRIVATEDATA >::ErrorType
ErrorType
Enumeration for error type.
Definition: fx_basic.h:1305
CFX_CMapDWordToDWord::RemoveAll
void RemoveAll()
Remove all (key, value) pair.
Definition: fx_basic.h:2701
IFX_BufferArchive::Clear
virtual void Clear()
Clear the text buffer.
CFX_TempBuf::~CFX_TempBuf
~CFX_TempBuf()
The Destructor.
Definition: fx_basic.h:2325
CFX_SortListArray
Definition: fx_basic.h:3950
CFX_DataFilter::SetDestFilter
void SetDestFilter(CFX_DataFilter *pFilter)
Set destination filter. Note the filter will be appended to the end of current filter chain.
CFX_ListArrayTemplate
Definition: fx_basic.h:4108
CFX_BitWriter::ByteAlign
void ByteAlign()
Get to byte boundary. If current bit position is not multiplication of 8, the rest of the current byt...
CFX_ArchiveSaver::operator<<
CFX_ArchiveSaver & operator<<(FX_BYTE i)
Left shifts(<<) operator overload. Serialize a single byte.
FX_LPCSTR
char const * FX_LPCSTR
Pointer to constant 8-bit Windows (ANSI) characters.
Definition: fx_system.h:705
CFX_UTF8Decoder::AppendChar
void AppendChar(FX_DWORD ch)
Append characters to wide text buffer.
CFX_PtrList
Definition: fx_basic.h:3033
CFX_ObjectArray::Append
FX_INT32 Append(const CFX_ObjectArray &src, FX_INT32 nStart=0, FX_INT32 nCount=-1)
Append an array.
Definition: fx_basic.h:1742
CFX_SortListArray::DataList::count
FX_INT32 count
The data count.
Definition: fx_basic.h:3958
CFX_SmartPointer::Get
T * Get(void)
Get the object pointer.
Definition: fx_basic.h:3926
FX_DecodeURI
CFX_WideString FX_DecodeURI(const CFX_ByteString &bsURI)
A simple URI Decode.
CFX_CharMap::m_GetWideString
CFX_WideString(* m_GetWideString)(CFX_CharMap *pMap, const CFX_ByteString &bstr)
A pointer type to GetWideString function.
Definition: fx_basic.h:982
CFX_SortListArray::DataList
The data list.
Definition: fx_basic.h:3954
CFX_MapPtrTemplate::GetNextAssoc
void GetNextAssoc(FX_POSITION &rNextPosition, KeyType &rKey, ValueType &rValue) const
Get the current association and set the position to next association.
Definition: fx_basic.h:2623
CFX_DataFilter::IsExhaustBuffer
FX_BOOL IsExhaustBuffer() const
Indicate whether this filter exhausts the input buffer.
Definition: fx_basic.h:3830
CFX_SortListArray::GetAt
FX_LPBYTE GetAt(FX_INT32 nIndex)
Get the data.
Definition: fx_basic.h:4043
IFX_FileStream
File stream interface, reading & writing.
Definition: fx_stream.h:692
CFX_ArrayTemplate::SetAtGrow
FX_BOOL SetAtGrow(int nIndex, TYPE newElement)
Set an element value at specified position. Potentially growing the array.
Definition: fx_basic.h:1456
Found
Found.
Definition: fx_basic.h:4180
CFX_UTF8Encoder::AppendStr
void AppendStr(FX_BSTR str)
Append a non-buffered byte string.
Definition: fx_basic.h:1109
CFX_ObjectStack::CFX_ObjectStack
CFX_ObjectStack()
Construct.
Definition: fx_basic.h:1948
IFX_BufferArchive::AppendBlock
FX_INT32 AppendBlock(const void *pBuf, size_t size)
Append a binary buffer block.
CFX_UTF8Decoder::GetResult
void GetResult(CFX_WideStringL &result) const
Get the result.
Definition: fx_basic.h:1069
CFX_FileSizeArray
CFX_ArrayTemplate< FX_INT64 > CFX_FileSizeArray
Type definition for file size array type.
Definition: fx_basic.h:1628
FX_UINTPTR
UINT_PTR FX_UINTPTR
Unsigned integral type for pointer precision.
Definition: fx_system.h:752
CFX_ArrayTemplate::InsertSpaceAt
TYPE * InsertSpaceAt(int nIndex, int nCount)
Insert a number of elements.
Definition: fx_basic.h:1524
CFX_PtrList::RemoveAt
void RemoveAt(FX_POSITION pos)
Remove a node at specified position.
CFX_MapByteStringToPtr::RemoveKey
FX_BOOL RemoveKey(FX_BSTR key)
Remove existing key.
CFX_CountRef::RefCount
int RefCount() const
Get the reference count.
Definition: fx_basic.h:3721
CFX_ArrayTemplate::RemoveAt
FX_BOOL RemoveAt(int nIndex, int nCount=1)
Remove a number of elements at specified position.
Definition: fx_basic.h:1591
IFX_Pause
Definition: fx_basic.h:3758
CFX_BitStream::Rewind
void Rewind()
Rewind a bit-stream. Simply set the current bit position to be zero.
Definition: fx_basic.h:3452
CFX_MapByteStringToPtr::GetHashTableSize
FX_DWORD GetHashTableSize() const
Get the internal hash table size. Advanced features for derived classes.
Definition: fx_basic.h:2832
CFX_WideStringArray
CFX_ObjectArray< CFX_WideString > CFX_WideStringArray
Type definition for a CFX_WideString array type.
Definition: fx_basic.h:1863
CFX_MapPtrToPtr::operator[]
void *& operator[](void *key)
Subscript([]) operator overload. Lookup and add if not there.
CFX_BinaryBuf::AttachData
void AttachData(void *pBuf, FX_STRSIZE size)
Attach to a buffer (this buffer will belong to this object). The buffer must be allocated by FX_Alloc...
CFX_CountRef::operator=
void operator=(const Ref &ref)
Assignment(=) operator overload. Assign from another reference.
Definition: fx_basic.h:3598
CFX_PtrList::GetNext
void * GetNext(FX_POSITION &rPosition) const
Get the the current value and set the position to next node.
Definition: fx_basic.h:3078
CFX_MapByteStringToPtr::CAssoc::nHashValue
FX_DWORD nHashValue
Cached hash value, needed for efficient iteration.
Definition: fx_basic.h:2724
CFX_BinaryBuf::DetachBuffer
void DetachBuffer()
Detach the buffer. Just set buffer pointer to NULL, and set the binary buffer size to zero.
CFX_PtrList::GetPrev
void * GetPrev(FX_POSITION &rPosition) const
Get the the current value and set the position to previous node.
Definition: fx_basic.h:3090
CFX_ArrayTemplate::CFX_ArrayTemplate
CFX_ArrayTemplate(const CFX_ArrayTemplate &other, IFX_Allocator *pAllocator=0)
The copy constructor.
Definition: fx_basic.h:1330
CFX_ObjectArray::AddSpace
void * AddSpace()
Add an empty space to the array.
Definition: fx_basic.h:1727
CFX_ObjectStack::Top
TYPE & Top()
Get the top byte string.
Definition: fx_basic.h:1975
CFX_PtrList::AddTail
FX_POSITION AddTail(void *newElement)
Add a value to the tail.
CFX_ArchiveSaver::Write
void Write(const void *pData, FX_STRSIZE dwSize)
Serialize a memory block.
CFX_SmartPointer::CFX_SmartPointer
CFX_SmartPointer(T *pObj)
The constructor.
Definition: fx_basic.h:3916
CFX_CountRef
Definition: fx_basic.h:3513
CFX_DataFilter::ResetStatistics
void ResetStatistics()
Reset statistics.
CFX_ArrayTemplate
Definition: fx_basic.h:1297
CFX_ArrayTemplate::GetAt
const TYPE GetAt(int nIndex) const
This method retrieves an element specified by an index number.
Definition: fx_basic.h:1396
CFX_ObjectArray::Add
ObjectClass & Add()
Add an empty object to the array.
Definition: fx_basic.h:1711
CFX_ArrayTemplate::CFX_ArrayTemplate
CFX_ArrayTemplate(IFX_Allocator *pAllocator=0)
Constructor, from an allocator.
Definition: fx_basic.h:1321
FX_LPBYTE
unsigned char * FX_LPBYTE
Pointer to a FX_BYTE.
Definition: fx_system.h:667
CFX_BinaryBuf::AppendByte
FX_BOOL AppendByte(FX_BYTE byte)
Append a single byte.
Definition: fx_basic.h:128
CFX_PtrList::Find
FX_POSITION Find(void *searchValue, FX_POSITION startAfter=0) const
Find a value starting after specified position.
FX_EncodeURI
CFX_ByteString FX_EncodeURI(const CFX_WideString &wsURI)
A simple URI encode.
CFX_SortListArray::Append
void Append(FX_INT32 nStart, FX_INT32 nCount)
Append a list data.
Definition: fx_basic.h:4006
CFX_CMapDWordToDWord::EstimateSize
void EstimateSize(FX_DWORD size, FX_DWORD grow_by)
Change internal allocation size and grow amount.
CFX_CountRef::CountedObj::CountedObj
CountedObj(const CountedObj &src)
The copy constructor.
Definition: fx_basic.h:3533
CFX_CMapDWordToDWord::Lookup
FX_BOOL Lookup(FX_DWORD key, FX_DWORD &value) const
Lookup by a key.
CFX_BinaryBuf::AppendBlock
FX_BOOL AppendBlock(const void *pBuf, FX_STRSIZE size)
Append a binary buffer block.
CFX_ArrayTemplate::GetData
const TYPE * GetData() const
Direct Access to the element data (may return NULL).
Definition: fx_basic.h:1439
CFX_ArrayTemplate::operator=
CFX_ArrayTemplate & operator=(const CFX_ArrayTemplate &src)
Assignment operator overload.
Definition: fx_basic.h:1533
FX_PRIVATEDATA::FreeData
void FreeData()
Free the private data pointed by m_pData.
CFX_ArrayTemplate::operator[]
const TYPE operator[](int nIndex) const
Subscript([]) operator overload. It retrieves a element specified by the zero-based index in nIndex.
Definition: fx_basic.h:1542
CFX_ByteArray
CFX_ArrayTemplate< FX_BYTE > CFX_ByteArray
Type definition for a byte array type.
Definition: fx_basic.h:1620
IFX_Allocator
Foxit allocator interface.
Definition: fx_memory.h:997
CFX_ByteTextBuf::AppendChar
void AppendChar(int ch)
Append a single character or byte.
Definition: fx_basic.h:278
CFX_BitStream::SkipBits
void SkipBits(FX_DWORD nBits)
Skip a number of bits.
Definition: fx_basic.h:3445
CFX_SegmentedArray::CFX_SegmentedArray
CFX_SegmentedArray(int segment_units, int index_size=8, IFX_Allocator *pAllocator=0)
Construct with specified segment units.
Definition: fx_basic.h:2203
CFX_PtrList::CNode::pPrev
CNode * pPrev
Pointer to previous node.
Definition: fx_basic.h:3042
CFX_Stack< CFX_ByteString >::Pop
void Pop()
Pop the byte string from stack.
Definition: fx_basic.h:2051
CFX_CharMap
Definition: fx_basic.h:956
CFX_CMapByteStringToPtr::RemoveAll
void RemoveAll()
Remove all key-value pairs in the map.
CFX_ArrayTemplate::invalidArraySize
Invalid array size.
Definition: fx_basic.h:1307
CFX_WideTextBuf::GetLength
FX_STRSIZE GetLength() const
Get the length of the wide text buffer.
Definition: fx_basic.h:442
CFX_SegmentedArray::Add
void Add(ElementType data)
Add an element.
Definition: fx_basic.h:2215
FX_FLOAT
float FX_FLOAT
32-bit floating-point number.
Definition: fx_system.h:685
CFX_MapByteStringToPtr::IsEmpty
FX_BOOL IsEmpty() const
Verify whether the map is empty.
Definition: fx_basic.h:2753
CFX_PtrList::FindIndex
FX_POSITION FindIndex(int index) const
Find a value by index number.
CFX_CountRef::CFX_CountRef
CFX_CountRef(const Ref &ref)
Copy constructor from another reference.
Definition: fx_basic.h:3552
FXSYS_assert
#define FXSYS_assert
Assertion.
Definition: fx_system.h:804
CFX_ArrayTemplate::AddSpace
TYPE * AddSpace()
Add an element's space.
Definition: fx_basic.h:1514
CFX_MapByteStringToPtr::CAssoc::pNext
CAssoc * pNext
Pointer to next association.
Definition: fx_basic.h:2721
CFX_ArrayTemplate::GetDataPtr
TYPE * GetDataPtr(int index)
Get a pointer to the specified element in the array. Direct pointer access.
Definition: fx_basic.h:1507
IFX_BufferArchive::AppendByte
FX_INT32 AppendByte(FX_BYTE byte)
Append a single byte.
CFX_MapPtrToPtr::GetCount
int GetCount() const
Get the number of elements.
Definition: fx_basic.h:2384
CFX_PtrList::SetAt
void SetAt(FX_POSITION pos, void *newElement)
Change the value at specified position.
Definition: fx_basic.h:3158
CFX_PtrList::AddHead
FX_POSITION AddHead(void *newElement)
Add a value to the head.
CFX_ArchiveSaver::CFX_ArchiveSaver
CFX_ArchiveSaver(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:494
CFX_FileBufferArchive::Clear
virtual void Clear()
Clear buffer.
CFX_BitWriter::WriteBits
void WriteBits(FX_INT64 value, FX_INT32 nBits)
Write a value of bits.
CFX_WideTextBuf::Delete
void Delete(int start_index, int count)
Delete a inter-zone buffer defining by parameters start_index and count in the wide text buffer.
Definition: fx_basic.h:459
CFX_ArrayTemplate::SetAt
FX_BOOL SetAt(int nIndex, TYPE newElement)
This method overwrites an element specified by an index number.
Definition: fx_basic.h:1412
CFX_ObjectArray::GetSize
int GetSize() const
Get the size of the array.
Definition: fx_basic.h:1808
CFX_Stack< CFX_ByteString >::Top
CFX_ByteString & Top()
Get the top byte string.
Definition: fx_basic.h:2041
CFX_BinaryBuf::InsertBlock
FX_BOOL InsertBlock(FX_STRSIZE pos, const void *pBuf, FX_STRSIZE size)
Insert a binary buffer block at the specified position.
CFX_PtrList::GetAt
void * GetAt(FX_POSITION rPosition) const
Get an value at specified position.
Definition: fx_basic.h:3120
CFX_PtrList::GetTailPosition
FX_POSITION GetTailPosition() const
Get the tail position.
Definition: fx_basic.h:3069
CFX_Stack::Empty
FX_BOOL Empty() const
Empty the container.
Definition: fx_basic.h:1880
CFX_AutoRestorer::~CFX_AutoRestorer
~CFX_AutoRestorer()
The destructor.
Definition: fx_basic.h:3900
CFX_BaseSegmentedArray::~CFX_BaseSegmentedArray
~CFX_BaseSegmentedArray()
The destructor.
CFX_MapPtrTemplate::CFX_MapPtrTemplate
CFX_MapPtrTemplate(IFX_Allocator *pAllocator=0)
Default constructor.
Definition: fx_basic.h:2567
CFX_UTF8Decoder
Definition: fx_basic.h:1011
CFX_ByteTextBuf::GetLength
FX_STRSIZE GetLength() const
Get the length of the byte text buffer.
Definition: fx_basic.h:339
CFX_MapPtrTemplate
Definition: fx_basic.h:2559
CFX_BinaryBuf::AppendString
void AppendString(FX_BSTR str)
Append a non-buffered byte string.
Definition: fx_basic.h:119
CFX_Stack< CFX_ByteString >::Empty
FX_BOOL Empty() const
Empty the container.
Definition: fx_basic.h:2021
FX_PRIVATEDATA
Definition: fx_basic.h:3258
CFX_TempBuf
Definition: fx_basic.h:2307
CFX_CMapByteStringToPtr::GetNextValue
FX_LPVOID GetNextValue(FX_POSITION &rNextPosition) const
Get the the current value and set the position to next association.
CFX_ArchiveLoader
Definition: fx_basic.h:651
CFX_CMapByteStringToPtr::GetNextAssoc
void GetNextAssoc(FX_POSITION &rNextPosition, CFX_ByteString &rKey, void *&rValue) const
Get the current association and set the position to next association.
CFX_SortListArray::CFX_SortListArray
CFX_SortListArray(IFX_Allocator *pAllocator=0)
The constructor.
Definition: fx_basic.h:3973
CFX_CMapDWordToDWord::m_Buffer
CFX_BinaryBuf m_Buffer
Definition: fx_basic.h:2705
Failed
Failed.
Definition: fx_basic.h:4184
CFX_MapPtrToPtr::CAssoc::key
void * key
Key data.
Definition: fx_basic.h:2358
CFX_WideTextBuf::GetBuffer
FX_LPWSTR GetBuffer() const
Get a wide character pointer.
Definition: fx_basic.h:449
CFX_FixedBufGrow::~CFX_FixedBufGrow
~CFX_FixedBufGrow()
The Destructor.
Definition: fx_basic.h:2292
Done
Done.
Definition: fx_basic.h:4186
CFX_ArrayTemplate::FX_Error
void FX_Error(ErrorType error, FX_INT32 badIndex=0) const
The function is called when raise a fatal error.Print error info an exit(1).
Definition: fx_basic.h:1341
CFX_FixedBufGrow::CFX_FixedBufGrow
CFX_FixedBufGrow(int data_size, IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:2260
CFX_ByteStringC
CONSTANT BYTE STRING CLASS.
Definition: fx_string.h:51
CFX_ArrayTemplate::GetData
TYPE * GetData()
Direct Access to the element data (may return NULL).
Definition: fx_basic.h:1446
CFX_ObjectArray
Definition: fx_basic.h:1645
CFX_ByteStringArray
CFX_ObjectArray< CFX_ByteString > CFX_ByteStringArray
Type definition for a CFX_ByteString array type.
Definition: fx_basic.h:1861
CFX_PrivateData::LookupPrivateData
FX_BOOL LookupPrivateData(FX_LPVOID module_id, FX_LPVOID &pData) const
Lookup a private data.
Definition: fx_basic.h:3358
CFX_SmartPointer::~CFX_SmartPointer
~CFX_SmartPointer()
The destructor.
Definition: fx_basic.h:3919
CFX_CountRef::New
ObjClass * New()
Create a new object and refer to it. The returned pointer to the object can be used to modify the con...
Definition: fx_basic.h:3577
CFX_CountRef::CountedObj
Define a class here derived from user data class, with an additional reference count member.
Definition: fx_basic.h:3522
CFX_FloatArray
CFX_ArrayTemplate< FX_FLOAT > CFX_FloatArray
Type definition for float array.
Definition: fx_basic.h:1630
CFX_UTF8Decoder::ClearStatus
void ClearStatus()
Clear the decoding status.
Definition: fx_basic.h:1053
CFX_SortListArray::~CFX_SortListArray
~CFX_SortListArray()
The destructor.
Definition: fx_basic.h:3976
IFX_BufferArchive::IFX_BufferArchive
IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator *pAllocator=0)
Construct with buffer size and special allocator.
CFX_MapPtrToPtr::GetHashTableSize
FX_DWORD GetHashTableSize() const
Get the internal hash table size. Advanced features for derived classes.
Definition: fx_basic.h:2473
CFX_MapByteStringToPtr::operator[]
void *& operator[](FX_BSTR key)
Subscript([]) operator overload. Lookup and add if not there.
CFX_CountRef::NotNull
FX_BOOL NotNull() const
Check if the pointer of the object is not NULL.
Definition: fx_basic.h:3660
CFX_CountRef::GetObjectF
const ObjClass * GetObjectF() const
Get a pointer of constant object. This pointer can't be used to alter the object content.
Definition: fx_basic.h:3632
CFX_Stack::Top
TYPE & Top()
Get the top byte data.
Definition: fx_basic.h:1900
CFX_MapPtrToPtr::RemoveKey
FX_BOOL RemoveKey(void *key)
Removing existing (key, ?) pair.
IFX_BufferArchive::AppendDWord
FX_INT32 AppendDWord(FX_DWORD i)
Append a FX_DWORD value.
CFX_MapByteStringToPtr::Lookup
FX_BOOL Lookup(FX_BSTR key, void *&rValue) const
Lookup by a key.
CFX_CMapByteStringToPtr::SetAt
void SetAt(FX_BSTR key, void *value)
Add a new (key, value) pair. Add if not exist, otherwise modify.
CFX_FixedBufGrow
Definition: fx_basic.h:2237
CFX_BitWriter::CFX_BitWriter
CFX_BitWriter(CFX_BinaryBuf *pBinBuf)
A constructor with bits write.
Definition: fx_basic.h:3474
CFX_ArrayTemplate::InsertAt
FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray *pNewArray)
Inset an array at specified position.
Definition: fx_basic.h:1601
CFX_FileBufferArchive::~CFX_FileBufferArchive
~CFX_FileBufferArchive()
The destructor.
CFX_ListArrayTemplate::Clear
void Clear()
Clear data.
Definition: fx_basic.h:4116
CFX_BinaryBuf::Delete
void Delete(int start_index, int count)
Delete a inter-zone buffer defining by parameters start_index and count in the binary buffer.
ToBeContinued
To be continued.
Definition: fx_basic.h:4178
FX_UrlDecode
CFX_WideString FX_UrlDecode(const CFX_ByteString &bsUrl)
A simple URL decode.
CFX_BitStream::GetBits
FX_DWORD GetBits(FX_DWORD nBits)
Get specified number of bits (maximum 32 bits).
CFX_MapPtrTemplate::operator[]
ValueType & operator[](KeyType key)
Subscript([]) operator overload. Lookup and add if not there.
Definition: fx_basic.h:2593
CFX_ByteString
BYTE STRING CLASS.
Definition: fx_string.h:317
CFX_CMapByteStringToPtr::Lookup
FX_BOOL Lookup(FX_BSTR key, void *&rValue) const
Lookup by a key.
CFX_PrivateData::SetPrivateData
void SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback)
Set private data.
CFX_ByteTextBuf::operator=
void operator=(FX_BSTR str)
Assignment(=) operator overload. From a non-buffered byte string.
CFX_CMapByteStringToPtr::CFX_CMapByteStringToPtr
CFX_CMapByteStringToPtr(IFX_Allocator *pAllocator=0)
The constructor.
IFX_BufferArchive::~IFX_BufferArchive
virtual ~IFX_BufferArchive()
The destructor.
Definition: fx_basic.h:790
CFX_BasicArray
Definition: fx_basic.h:1176
CFX_BinaryBuf::CopyData
FX_BOOL CopyData(const void *pBuf, FX_STRSIZE size)
Copy from another buffer.
CFX_AutoRestorer::CFX_AutoRestorer
CFX_AutoRestorer(T *location)
The constructor.
Definition: fx_basic.h:3894
FX_LPCBYTE
unsigned char const * FX_LPCBYTE
Pointer to a constant FX_BYTE.
Definition: fx_system.h:669
CFX_BinaryBuf::GetBuffer
FX_LPBYTE GetBuffer() const
Get a byte pointer to the binary buffer.
Definition: fx_basic.h:196
fx_memory.h
Header file for Memory management related definitions and classes.
CFX_FixedBufGrow::SetDataSize
void SetDataSize(int data_size)
Construct with allocator.
Definition: fx_basic.h:2278
CFX_MapPtrToPtr::Lookup
FX_BOOL Lookup(void *key, void *&rValue) const
Lookup by a key.
FX_ProgressiveStatus
FX_ProgressiveStatus
Enumeration for progressive status.
Definition: fx_basic.h:4174
CFX_Stack::Pop
void Pop()
Pop the data from stack.
Definition: fx_basic.h:1910
FX_LPWSTR
wchar_t * FX_LPWSTR
Pointer to Unicode characters.
Definition: fx_system.h:734
CFX_DataFilter::NeedNewSrc
FX_BOOL NeedNewSrc()
Indicate whether this filter needs to input new src data.
CFX_ArrayTemplate::InsertAt
FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount=1)
Inset one or more continuous element at specified position.
Definition: fx_basic.h:1575
CFX_ArrayTemplate::indexOutOfRange
Index out of range.
Definition: fx_basic.h:1313
CFX_BaseSegmentedArray::m_pAllocator
IFX_Allocator * m_pAllocator
Special allocator pointer. NULL means to use default allocator.
Definition: fx_basic.h:2169
CFX_DataFilter::IsEOF
FX_BOOL IsEOF() const
Detect EOF.
Definition: fx_basic.h:3795
CFX_ObjectStack::Push
void Push(const TYPE &val)
Push the byte string to stack.
Definition: fx_basic.h:1997
CFX_CMapByteStringToPtr::~CFX_CMapByteStringToPtr
~CFX_CMapByteStringToPtr()
The destructor.
CFX_BinaryBuf::TakeOver
void TakeOver(CFX_BinaryBuf &other)
Takeover another buffer.
NULL
#define NULL
The null-pointer value.
Definition: fx_system.h:792
CFX_MapPtrToPtr::GetValueAt
void * GetValueAt(void *key) const
Get a value pointer by a key.
IFX_BufferArchive::AppendInt64
FX_INT32 AppendInt64(FX_INT64 i)
Append a FX_INT64 value.
CFX_ArchiveLoader::operator >>
CFX_ArchiveLoader & operator >>(FX_BYTE &i)
Right shifts(>>) operator overload. De-serialize a byte.
CFX_ArrayTemplate::GetUpperBound
int GetUpperBound() const
Get the upper bound in the array, actually the maximum valid index.
Definition: fx_basic.h:1367
CFX_ObjectStack::Size
int Size() const
Get size of the container.
Definition: fx_basic.h:1965
CFX_CMapByteStringToPtr::RemoveKey
void RemoveKey(FX_BSTR key)
Removing existing (key, ?) pair.
CFX_CMapDWordToDWord
Definition: fx_basic.h:2638
CFX_MapPtrToPtr
Definition: fx_basic.h:2347
CFX_BitWriter
Definition: fx_basic.h:3466
CFX_BitStream::IsEOF
FX_BOOL IsEOF() const
Check if reached end of the stream.
Definition: fx_basic.h:3436
FX_UrlEncode
CFX_ByteString FX_UrlEncode(const CFX_WideString &wsUrl)
A simple URL encode.
CFX_Stack::Push
void Push(const TYPE &val)
Push the data to stack.
Definition: fx_basic.h:1922
FX_FILESIZE
#define FX_FILESIZE
Support large file directly.
Definition: fx_stream.h:155
CFX_MapPtrToPtr::GetStartPosition
FX_POSITION GetStartPosition() const
Get the first key-value pair position. iterating all (key, value) pairs.
Definition: fx_basic.h:2452
CFX_MapByteStringToPtr
Definition: fx_basic.h:2712
CFX_SortListArray::Clear
void Clear()
Clear the data list.
Definition: fx_basic.h:3986
CFX_CountRef::CountedObj::CountedObj
CountedObj()
The constructor.
Definition: fx_basic.h:3526
CFX_ObjectArray::RemoveAll
void RemoveAll()
Remove all objects in the array.
Definition: fx_basic.h:1852
CFX_PtrList::GetCount
int GetCount() const
Get the number of nodes.
Definition: fx_basic.h:3130
CFX_DataFilter::AbortAll
FX_BOOL AbortAll()
Indicate whether to abort the filter process, including all dest filter.
CFX_CountRef::GetModify
ObjClass * GetModify()
Get a modifiable copy of the object.
Definition: fx_basic.h:3673
CFX_CMapDWordToDWord::GetNextAssoc
void GetNextAssoc(FX_POSITION &pos, FX_DWORD &key, FX_DWORD &value) const
Get the next association.
CFX_MapPtrToPtr::RemoveAll
void RemoveAll()
Remove all the (key, value) pairs in the map.
CFX_Stack::Size
int Size() const
Get size of the container.
Definition: fx_basic.h:1890
FX_Allocator_Free
#define FX_Allocator_Free(fxAllocator, ptr)
Free memory block on an allocator.
Definition: fx_memory.h:1094
CFX_PtrList::GetPrevPosition
FX_POSITION GetPrevPosition(FX_POSITION pos) const
Get the previous position.
Definition: fx_basic.h:3111
CFX_WideTextBuf::GetWideString
CFX_WideStringC GetWideString() const
Get a wide string from the wide text buffer.
CFX_MapPtrToPtr::~CFX_MapPtrToPtr
~CFX_MapPtrToPtr()
The Destructor.
CFX_ArchiveLoader::CFX_ArchiveLoader
CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize)
Construct a loading archive.
FX_PRIVATEDATA::m_pCallback
PD_CALLBACK_FREEDATA m_pCallback
Pointer of a callback function provided by custom module for deallocating private data.
Definition: fx_basic.h:3274
CFX_BinaryBuf::GetSize
FX_STRSIZE GetSize() const
Get the length of the binary buffer.
Definition: fx_basic.h:203
CFX_CharMap::m_GetByteString
CFX_ByteString(* m_GetByteString)(CFX_CharMap *pMap, const CFX_WideString &wstr)
A pointer type to GetByteString function.
Definition: fx_basic.h:995
CFX_BitStream
Definition: fx_basic.h:3402
CFX_CountRef::SetNull
void SetNull()
Set the pointer of the object to be null.
Definition: fx_basic.h:3695
CFX_AutoRestorer
Definition: fx_basic.h:3887
CFX_WCHARArray
CFX_ArrayTemplate< FX_WCHAR > CFX_WCHARArray
Type definition for FX_WHAR array.
Definition: fx_basic.h:1634
IFX_BufferArchive::AppendString
FX_INT32 AppendString(FX_BSTR lpsz)
Append a byte string value.
CFX_MapPtrToPtr::InitHashTable
void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow=true)
Initialize the hash table.
CFX_CountRef::operator==
FX_BOOL operator==(const Ref &ref) const
Comparison(==) operator overload. Compare with another reference.
Definition: fx_basic.h:3711
CFX_ObjectArray::GetDataPtr
ObjectClass * GetDataPtr(int index) const
Get a pointer to the specified element in the array. Direct pointer access.
Definition: fx_basic.h:1831
CFX_MapByteStringToPtr::CAssoc::value
void * value
Value data.
Definition: fx_basic.h:2728
FX_INTPTR
INT_PTR FX_INTPTR
Signed integral type for pointer precision.
Definition: fx_system.h:750
fx_exception.h
Header file for exception class.
FX_BYTE
unsigned char FX_BYTE
Byte (8 bits).
Definition: fx_system.h:665
CFX_BaseSegmentedArray::GetAt
void * GetAt(int index) const
Get a typeless pointer to an element data.
CFX_BaseSegmentedArray::RemoveAll
void RemoveAll()
Remove all elements in the array.
CFX_ObjectStack::Pop
void Pop()
Pop the byte string from stack.
Definition: fx_basic.h:1985
CFX_FileBufferArchive
Definition: fx_basic.h:877
CFX_CountRef::Decref
void Decref()
Decrease the reference.
Definition: fx_basic.h:3742
IFX_Pause::~IFX_Pause
virtual ~IFX_Pause()
Destructor.
Definition: fx_basic.h:3762
CFX_PtrArray
CFX_ArrayTemplate< void * > CFX_PtrArray
Type definition for: a typeless pointer array type.
Definition: fx_basic.h:1626
CFX_ArchiveSaver
Definition: fx_basic.h:485
CFX_BaseSegmentedArray::CFX_BaseSegmentedArray
CFX_BaseSegmentedArray(int unit_size=1, int segment_units=512, int index_size=8, IFX_Allocator *pAllocator=0)
Construct with specified unit size, segment units, and number of index levels.
CFX_ArrayTemplate::Find
int Find(const TYPE &data, int iStart=0) const
Find an element from specified position to last.
Definition: fx_basic.h:1610
CFX_UTF8Decoder::Input
void Input(FX_BYTE byte)
Input a byte.
fx_system.h
Header file for system related definitions.
CFX_MapByteStringToPtr::GetNextValue
FX_LPVOID GetNextValue(FX_POSITION &rNextPosition) const
Get the the current value and set the position to next association.
CFX_BinaryBuf::GetByteString
CFX_ByteStringC GetByteString() const
Get a byte string from the buffer.
CFX_ListArrayTemplate::Add
void Add(FX_INT32 nStart, FX_INT32 nCount)
Add a list data.
Definition: fx_basic.h:4129
CFX_MapPtrToPtr::CAssoc::pNext
CAssoc * pNext
Pointer to next association.
Definition: fx_basic.h:2356