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 
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 
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 
211 
219  void GetByteStringL(CFX_ByteStringL &str) const;
220 
226  void DetachBuffer();
227 
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 
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 
288 
297 
305  CFX_ByteTextBuf& operator << (double f);
306 
315 
324 
330  FX_STRSIZE GetLength() const { return m_DataSize; }
331 };
332 
337 {
338  public:
345  CFX_WideTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}
346 
354  void operator = (FX_LPCWSTR lpsz);
355 
363  void operator = (FX_WSTR str);
364 
373 
382 
390  CFX_WideTextBuf& operator << (double f);
391 
400 
409 
418 
427 
433  FX_STRSIZE GetLength() const { return m_DataSize/sizeof(FX_WCHAR); }
434 
440  FX_LPWSTR GetBuffer() const { return (FX_LPWSTR)m_pBuffer; }
441 
450  void Delete(int start_index, int count)
451  {
452  CFX_BinaryBuf::Delete(start_index * sizeof(FX_WCHAR), count * sizeof(FX_WCHAR));
453  }
454 
461 
462  void GetWideStringL(CFX_WideStringL& wideText) const;
463 
464 };
465 
466 //*****************************************************************************
467 //* Archive
468 //*****************************************************************************
476 class CFX_ArchiveSaver : public CFX_Object
477 {
478  public:
485  CFX_ArchiveSaver(IFX_Allocator* pAllocator = NULL) : m_SavingBuf(pAllocator), m_pStream(NULL) {}
486 
495 
504 
513 
522 
531 
540 
548  CFX_ArchiveSaver& operator << (double i);
549 
558 
567 
576 
587 
598 
607  void Write(const void* pData, FX_STRSIZE dwSize);
608 
614  FX_INTPTR GetLength() const { return m_SavingBuf.GetSize(); }
615 
621  FX_LPCBYTE GetBuffer() const { return m_SavingBuf.GetBuffer(); }
622 
630  void SetStream(IFX_FileStream* pStream) { m_pStream = pStream; }
631 
632  protected:
633  /* Saving data. */
634  CFX_BinaryBuf m_SavingBuf;
635  /* Stream data. */
636  IFX_FileStream* m_pStream;
637 };
638 
642 class CFX_ArchiveLoader : public CFX_Object
643 {
644  public:
653  CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize);
654 
663 
672 
681 
690 
699 
708 
716  CFX_ArchiveLoader& operator >> (double& i);
717 
726 
735 
741  FX_BOOL IsEOF();
742 
751  FX_BOOL Read(void* pBuf, FX_DWORD dwSize);
752 
753  protected:
754  /* Current loading position. */
755  FX_DWORD m_LoadingPos;
756  /* Loading buffer. */
757  FX_LPCBYTE m_pLoadingBuf;
758  /* The size in bytes of the loading buffer. */
759  FX_DWORD m_LoadingSize;
760 };
761 
766 {
767  public:
775  IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
776  //<<<+++OPENSOURCE_END
777 
781  virtual ~IFX_BufferArchive() {}
782 
788  virtual void Clear();
789 
795  FX_BOOL Flush();
796 
805  FX_INT32 AppendBlock(const void* pBuf, size_t size);
806 
815 
824 
833 
842 
843  protected:
844  /*
845  * @brief Do work, it will be called when the text buffer is full.
846  *
847  * @param[in] pBuf A pointer to a binary buffer block.
848  * @param[in] size The size in bytes of the buffer block.
849  *
850  * @return <b>true</b> means success, while <b>false</b> means failure.
851  */
852  virtual FX_BOOL DoWork(const void* pBuf, size_t size) = 0;
853 
854  /* Special allocator pointer. NULL to use default allocator. */
855  IFX_Allocator* m_pAllocator;
856 
857  /* The buffer size*/
858  FX_STRSIZE m_BufSize;
859  /* Buffer. */
860  FX_LPBYTE m_pBuffer;
861  /* Current buffer length. */
862  FX_STRSIZE m_Length;
863 };
864 
868 class CFX_FileBufferArchive : public IFX_BufferArchive, public CFX_Object
869 {
870  public:
877  CFX_FileBufferArchive(FX_STRSIZE size = 32768, IFX_Allocator* pAllocator = NULL);
878 
883 
889  virtual void Clear();
890 
896  FX_BOOL Flush();
897 
906  FX_BOOL AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover = false);
907 
915  FX_BOOL AttachFile(FX_LPCWSTR filename);
916 
924  FX_BOOL AttachFile(FX_LPCSTR filename);
925 
926  private:
927  /*
928  * Do work, it will be called when the text buffer is full.
929  *
930  * @param[in] pBuf A pointer to a binary buffer block.
931  * @param[in] size The size in bytes of the buffer block.
932  *
933  * @return <b>true</b> means success, while <b>false</b> means failure.
934  */
935  virtual FX_BOOL DoWork(const void* pBuf, size_t size);
936 
937  /* The file stream. */
938  IFX_StreamWrite *m_pFile;
939  /* whether take over the file. */
940  FX_BOOL m_bTakeover;
941 };
942 
948 {
959  static CFX_CharMap* GetDefaultMapper(FX_INT32 codepage = 0);
960 
974 
987 
994 };
995 
996 //*****************************************************************************
997 //* UTF-8
998 //*****************************************************************************
1003 {
1004  public:
1012  CFX_UTF8Decoder(IFX_Allocator* pAllocator = NULL) : m_PendingBytes(0),m_PendingChar(0),m_Buffer(pAllocator) { }
1013 
1019  void Clear();
1020 
1028  void Input(FX_BYTE byte);
1029 
1037  void AppendChar(FX_DWORD ch);
1038 
1044  void ClearStatus() { m_PendingBytes = 0; }
1045 
1051  CFX_WideStringC GetResult() const { return m_Buffer.GetWideString(); }
1052 
1060  void GetResult(CFX_WideStringL &result) const {m_Buffer.GetWideStringL(result);}
1061 
1062  protected:
1063  /* The decoding status. */
1064  int m_PendingBytes;
1065  /* Cached value. */
1066  FX_DWORD m_PendingChar;
1067  /* The output wide text buffer. */
1068  CFX_WideTextBuf m_Buffer;
1069 };
1070 
1075 {
1076  public:
1082  CFX_UTF8Encoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) { m_UTF16First = 0; }
1083 
1091  void Input(FX_WCHAR unicode);
1092 
1100  void AppendStr(FX_BSTR str) { m_UTF16First = 0; m_Buffer << str; }
1101 
1107  CFX_ByteStringC GetResult() const { return m_Buffer.GetByteString(); }
1108 
1116  void GetResult(CFX_ByteStringL &result) const {m_Buffer.GetByteStringL(result);}
1117 
1118  protected:
1119  /* The output byte text buffer. */
1120  CFX_ByteTextBuf m_Buffer;
1121  /* The encoding status. */
1122  FX_DWORD m_UTF16First;
1123 };
1124 
1133 
1142 
1151 
1160 
1161 //*****************************************************************************
1162 //* Array
1163 //*****************************************************************************
1167 class CFX_BasicArray : public CFX_Object
1168 {
1169  public:
1172 
1173  protected:
1174  /*
1175  * @brief Construct with specified unit size.
1176  *
1177  * @param[in] unit_size The specified unit size. Must be greater than 0 and less than 2^28.
1178  * @param[in] pAllocator Allocator used in this class. <b>NULL</b> means to use default allocator.
1179  * Default value: <b>NULL</b>.
1180  */
1181  CFX_BasicArray(int unit_size, IFX_Allocator* pAllocator = NULL);
1182  //<<<+++OPENSOURCE_END
1183 
1184  /*
1185  * @brief The destructor.
1186  */
1187  ~CFX_BasicArray();
1188 
1189  /*
1190  * @brief The copy constructor.
1191  *
1192  * @param[in] other The other CFX_BasicArray object.
1193  * @param[in] pAllocator An allocator.
1194  */
1195  CFX_BasicArray(const CFX_BasicArray& other, IFX_Allocator* pAllocator = NULL);
1196 
1197  /*
1198  * @brief The assignment operator.
1199  *
1200  * @param[in] other The other CFX_BasicArray object.
1201  *
1202  * @return Reference to current object itself.
1203  */
1204  CFX_BasicArray& operator=(const CFX_BasicArray& other);
1205 
1206  /*
1207  * @brief Change the allocated size and the grow amount.
1208  *
1209  * @param[in] nNewSize The new size in elements expected.
1210  * @param[in] nGrowBy The grow amount in elements expected, nGrowBy can be -1 for the grow amount unchanged.
1211  *
1212  * @return <b>true</b> means success, while <b>false</b> means failure (such as parameter or memory error).
1213  */
1214  FX_BOOL SetSize(int nNewSize, int nGrowBy);
1215 
1216  /*
1217  * @brief Append a basic array.
1218  *
1219  * @param[in] src The input basic array. It must have the save unit size as the current array.
1220  *
1221  * @return <b>true</b> means success, while <b>false</b> means failure (such as memory error).
1222  */
1223  FX_BOOL Append(const CFX_BasicArray& src);
1224 
1225  /*
1226  * @brief Copy from 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 Copy(const CFX_BasicArray& src);
1233 
1234  /*
1235  * @brief Insert spaces at specified position.
1236  *
1237  * @param[in] nIndex Specifies the zero-based index of element in the basic array.
1238  * @param[in] nCount Specifies the count of element to insert.
1239  *
1240  * @return A byte pointer to the inserted space. <b>NULL</b> means error.
1241  */
1242  FX_LPBYTE InsertSpaceAt(int nIndex, int nCount);
1243 
1244  /*
1245  * @brief Remove a number of elements.
1246  *
1247  * @param[in] nIndex Specifies the zero-based index of start element in the basic array to be removed.
1248  * @param[in] nCount Specifies the count of element to remove.
1249  *
1250  * @return <b>true</b> means success, while <b>false</b> means failure (such as parameter error).
1251  */
1252  FX_BOOL RemoveAt(int nIndex, int nCount);
1253 
1254  /*
1255  * @brief Insert a basic array at specified position.
1256  *
1257  * @param[in] nStartIndex Specifies the zero-based index of start element to insert at.
1258  * @param[in] pNewArray The input basic array. It must have the save unit size as the current array.
1259  *
1260  * @return <b>true</b> means success, while <b>false</b> means failure (such as parameter or memory error).
1261  */
1262  FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
1263 
1264  /*
1265  * @brief Get a typeless pointer to an element data.
1266  *
1267  * @param[in] index Specifies the zero-based index of element.
1268  *
1269  * @return A typeless pointer to the element data. <b>NULL</b> means error.
1270  */
1271  const void* GetDataPtr(int index) const;
1272 
1273  protected:
1274  /* The actual array of data */
1275  FX_LPBYTE m_pData;
1276  /* # of elements (upperBound - 1) */
1277  int m_nSize;
1278  /* Max allocated */
1279  int m_nMaxSize;
1280  /* Grow amount. */
1281  int m_nGrowBy;
1282  /* Number of bytes in one unit. */
1283  int m_nUnitSize;
1284 };
1285 
1287 template<class TYPE>
1289 {
1290  public:
1299 
1302 
1305  };
1306 
1312  CFX_ArrayTemplate(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(TYPE), pAllocator) {}
1313  //<<<+++OPENSOURCE_END
1314 
1321  CFX_ArrayTemplate(const CFX_ArrayTemplate& other, IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(other, pAllocator) {}
1322 
1332  void FX_Error(ErrorType error,FX_INT32 badIndex=0) const
1333  {
1334  const char *errorMsg[] = {
1335  "Invalid array size",
1336  "Memory allocation error",
1337  "Invalid index:"
1338  };
1339 
1340  fprintf(stderr, "%s\n", errorMsg[error]);
1341  if(error == indexOutOfRange)
1342  fprintf(stderr, "%i\n", badIndex);
1343  abort();
1344  }
1345 
1351  int GetSize() const { return m_nSize; }
1352 
1358  int GetUpperBound() const { return m_nSize-1; }
1359 
1368  FX_BOOL SetSize(int nNewSize, int nGrowBy = -1)
1369  {
1370  return CFX_BasicArray::SetSize(nNewSize, nGrowBy);
1371  }
1372 
1378  void RemoveAll() { SetSize(0, -1); }
1379 
1387  const TYPE GetAt(int nIndex) const {
1388  if (nIndex < 0 || nIndex >= m_nSize)
1389  //return (const TYPE&)(*(volatile const TYPE*)NULL);
1390  //In order to avoid crash, we input the index.(For reasons unknown)
1391  FX_Error(indexOutOfRange, nIndex);
1392  return ((const TYPE*)m_pData)[nIndex];
1393  }
1394 
1403  FX_BOOL SetAt(int nIndex, TYPE newElement) {
1404  if (nIndex < 0 || nIndex >= m_nSize) return false;
1405  ((TYPE*)m_pData)[nIndex] = newElement;
1406  return true;
1407  }
1408 
1416  TYPE& ElementAt(int nIndex)
1417  {
1418  if (nIndex < 0 || nIndex >= m_nSize)
1419  //return *(TYPE*)NULL;
1420  //In order to avoid crash, we input the index.(For reasons unknown)
1421  FX_Error(indexOutOfRange, nIndex);
1422  return ((TYPE*)m_pData)[nIndex];
1423  }
1424 
1430  const TYPE* GetData() const { return (const TYPE*)m_pData; }
1431 
1437  TYPE* GetData() { return (TYPE*)m_pData; }
1438 
1447  FX_BOOL SetAtGrow(int nIndex, TYPE newElement)
1448  {
1449  if (nIndex < 0) return false;
1450  if (nIndex >= m_nSize)
1451  if (!SetSize(nIndex+1, -1)) return false;
1452  ((TYPE*)m_pData)[nIndex] = newElement;
1453  return true;
1454  }
1455 
1463  FX_BOOL Add(TYPE newElement)
1464  {
1465  if (m_nSize < m_nMaxSize)
1466  m_nSize ++;
1467  else
1468  if (!SetSize(m_nSize+1, -1)) return false;
1469  ((TYPE*)m_pData)[m_nSize-1] = newElement;
1470  return true;
1471  }
1472 
1480  FX_BOOL Append(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Append(src); }
1481 
1489  FX_BOOL Copy(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Copy(src); }
1490 
1498  TYPE* GetDataPtr(int index) { return (TYPE*)CFX_BasicArray::GetDataPtr(index); }
1499 
1505  TYPE* AddSpace() { return (TYPE*)CFX_BasicArray::InsertSpaceAt(m_nSize, 1); }
1506 
1515  TYPE* InsertSpaceAt(int nIndex, int nCount) { return (TYPE*)CFX_BasicArray::InsertSpaceAt(nIndex, nCount); }
1516 
1524  CFX_ArrayTemplate& operator=(const CFX_ArrayTemplate& src) { CFX_BasicArray::operator=(src); return *this; }
1525 
1533  const TYPE operator[](int nIndex) const
1534  {
1535  if (nIndex < 0 || nIndex >= m_nSize)
1536  //Merge from google trunk r2049, author: Johnson, date:2012.12.07
1537  *(volatile char*)0 = '\0';
1538  return ((const TYPE*)m_pData)[nIndex];
1539  }
1540 
1549  TYPE& operator[](int nIndex)
1550  {
1551  if (nIndex < 0 || nIndex >= m_nSize)
1552  //Merge from google trunk r2049, author: Johnson, date:2012.12.07
1553  *(volatile char*)0 = '\0';
1554  return ((TYPE*)m_pData)[nIndex];
1555  }
1556 
1566  FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount = 1)
1567  {
1568  if (!InsertSpaceAt(nIndex, nCount)) return false;
1569  while (nCount--)
1570  ((TYPE*)m_pData)[nIndex++] = newElement;
1571  return true;
1572  }
1573 
1582  FX_BOOL RemoveAt(int nIndex, int nCount = 1) { return CFX_BasicArray::RemoveAt(nIndex, nCount); }
1583 
1592  FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray) { return CFX_BasicArray::InsertAt(nStartIndex, pNewArray); }
1601  int Find(const TYPE& data, int iStart = 0) const
1602  {
1603  if (iStart < 0) return -1;
1604  for (; iStart < (int)m_nSize; iStart ++)
1605  if (((TYPE*)m_pData)[iStart] == data) return iStart;
1606  return -1;
1607  }
1608 };
1609 
1626 
1635 template <class ObjectClass>
1637 {
1638  public:
1644  CFX_ObjectArray(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(ObjectClass), pAllocator) {}
1645 
1650 
1657  CFX_ObjectArray(const CFX_ObjectArray& other, IFX_Allocator* pAllocator = NULL)
1658  : CFX_BasicArray(sizeof(ObjectClass), pAllocator)
1659  {
1660  Copy(other);
1661  }
1662 
1671  {
1672  Copy(other);
1673  return *this;
1674  }
1675 
1685  void Add(const ObjectClass& data)
1686  {
1687  #ifndef _FX_NOPLACEMENTNEW_
1688  new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
1689  #else
1690  ::new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
1691  #endif
1692 
1693  }
1694 
1702  ObjectClass& Add()
1703  {
1704  #ifndef _FX_NOPLACEMENTNEW_
1705  return *(ObjectClass*) new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
1706  #else
1707  return *(ObjectClass*) ::new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
1708  #endif
1709  }
1710 
1718  void* AddSpace()
1719  {
1720  return InsertSpaceAt(m_nSize, 1);
1721  }
1722 
1733  FX_INT32 Append(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
1734  {
1735  if (nCount == 0) return 0;
1736  FX_INT32 nSize = src.GetSize();
1737  if (!nSize) return 0;
1738  FXSYS_assert(nStart > -1 && nStart < nSize);
1739  if (nCount < 0) nCount = nSize;
1740  if (nStart + nCount > nSize) nCount = nSize - nStart;
1741  if (nCount < 1) return 0;
1742  nSize = m_nSize;
1743  InsertSpaceAt(m_nSize, nCount);
1744  ObjectClass* pStartObj = (ObjectClass*)GetDataPtr(nSize);
1745  nSize = nStart + nCount;
1746  for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++)
1747  {
1748  #ifndef _FX_NOPLACEMENTNEW_
1749  new ((void*)pStartObj) ObjectClass(src[i]);
1750  #else
1751  ::new ((void*)pStartObj) ObjectClass(src[i]);
1752  #endif
1753 
1754  }
1755  return nCount;
1756  }
1757 
1768  FX_INT32 Copy(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
1769  {
1770  if (this == &src) return 0;
1771  RemoveAll();
1772  if (nCount == 0) return 0;
1773  FX_INT32 nSize = src.GetSize();
1774  if (!nSize) return 0;
1775  FXSYS_assert(nStart > -1 && nStart < nSize);
1776  if (nCount < 0) nCount = nSize;
1777  if (nStart + nCount > nSize) nCount = nSize - nStart;
1778  if (nCount < 1) return 0;
1779  nSize = nStart + nCount;
1780  SetSize(nCount, -1);
1781  ObjectClass* pStartObj = (ObjectClass*)m_pData;
1782  for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++)
1783  {
1784  #ifndef _FX_NOPLACEMENTNEW_
1785  new ((void*)pStartObj) ObjectClass(src[i]);
1786  #else
1787  ::new ((void*)pStartObj) ObjectClass(src[i]);
1788  #endif
1789 
1790  }
1791  return nCount;
1792  }
1793 
1799  int GetSize() const {return m_nSize;}
1800 
1809  ObjectClass& operator[] (int index) const
1810  {
1811  FXSYS_assert(index < m_nSize);
1812  return *(ObjectClass*)CFX_BasicArray::GetDataPtr(index);
1813  }
1814 
1822  ObjectClass* GetDataPtr(int index) const {return (ObjectClass*)CFX_BasicArray::GetDataPtr(index);}
1823 
1831  void RemoveAt(int index)
1832  {
1833  FXSYS_assert(index < m_nSize);
1834  ((ObjectClass*)GetDataPtr(index))->~ObjectClass();
1835  CFX_BasicArray::RemoveAt(index, 1);
1836  }
1837 
1843  void RemoveAll()
1844  {
1845  for (int i = 0; i < m_nSize; i ++)
1846  ((ObjectClass*)GetDataPtr(i))->~ObjectClass();
1847  CFX_BasicArray::SetSize(0, -1);
1848  }
1849 };
1850 
1855 
1859 template <class TYPE>
1860 class CFX_Stack : CFX_Object
1861 {
1862  public:
1865 
1871  FX_BOOL Empty() const
1872  {
1873  return m_Container.GetSize() == 0;
1874  }
1875 
1881  int Size() const
1882  {
1883  return m_Container.GetSize();
1884  }
1885 
1891  TYPE& Top()
1892  {
1893  return m_Container[Size() - 1];
1894  }
1895 
1901  void Pop()
1902  {
1903  m_Container.RemoveAt(Size() - 1);
1904  }
1905 
1913  void Push(const TYPE& val)
1914  {
1915  m_Container.Add(val);
1916  }
1917 
1923  void Clear()
1924  {
1925  m_Container.RemoveAll();
1926  }
1927  private:
1928  CFX_ArrayTemplate<TYPE> m_Container;
1929 };
1930 
1934 template <class TYPE>
1935 class CFX_ObjectStack : CFX_Object
1936 {
1937  public:
1940 
1946  FX_BOOL Empty() const
1947  {
1948  return m_Container.GetSize() == 0;
1949  }
1950 
1956  int Size() const
1957  {
1958  return m_Container.GetSize();
1959  }
1960 
1966  TYPE& Top()
1967  {
1968  return m_Container[Size() - 1];
1969  }
1970 
1976  void Pop()
1977  {
1978  m_Container.RemoveAt(Size() - 1);
1979  }
1980 
1988  void Push(const TYPE& val)
1989  {
1990  m_Container.Add(val);
1991  }
1992 
1993  private:
1994  CFX_ObjectArray<TYPE> m_Container;
1995 };
1996 
2000 template <>
2001 class CFX_Stack<CFX_ByteString> : CFX_Object
2002 {
2003  public:
2006 
2012  FX_BOOL Empty() const
2013  {
2014  return m_Container.GetSize() == 0;
2015  }
2016 
2022  int Size() const
2023  {
2024  return m_Container.GetSize();
2025  }
2026 
2033  {
2034  return m_Container[Size() - 1];
2035  }
2036 
2042  void Pop()
2043  {
2044  m_Container.RemoveAt(Size() - 1);
2045  }
2046 
2054  void Push(const CFX_ByteString& val)
2055  {
2056  m_Container.Add(val);
2057  }
2058 
2059  private:
2060  CFX_ObjectArray<CFX_ByteString> m_Container;
2061 };
2062 
2066 class CFX_BaseSegmentedArray : public CFX_Object
2067 {
2068  public:
2077  CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8, IFX_Allocator* pAllocator = NULL);
2078 
2083 
2093  void SetUnitSize(int unit_size, int segment_units, int index_size = 8);
2094 
2100  void* Add();
2101 
2109  void* GetAt(int index) const;
2110 
2116  void RemoveAll();
2117 
2126  void Delete(int index, int count = 1);
2127 
2133  int GetSize() const { return m_DataSize; }
2134 
2140  int GetSegmentSize() const { return m_SegmentSize; }
2141 
2147  int GetUnitSize() const { return m_UnitSize; }
2148 
2157  void* Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2158 
2161  private:
2162  /* Unit size */
2163  int m_UnitSize;
2164  /* Count of units in each segment. */
2165  short m_SegmentSize;
2166  /* Number of index level in the array. */
2167  FX_BYTE m_IndexSize;
2168  /* The current level in the index tree. */
2169  FX_BYTE m_IndexDepth;
2170  /* The current number of units in the array. */
2171  int m_DataSize;
2172  /* index to segments or indices, or directly pointing to the segment if only one segment. */
2173  void* m_pIndex;
2174 
2175  void** GetIndex(int seg_index) const;
2176  void* IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2177  void* IterateSegment(FX_LPCBYTE pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
2178 };
2179 
2183 template <class ElementType>
2185 {
2186  public:
2194  CFX_SegmentedArray(int segment_units, int index_size = 8, IFX_Allocator* pAllocator = NULL)
2195  : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size, pAllocator)
2196  {}
2197  //<<<+++OPENSOURCE_END
2198 
2206  void Add(ElementType data)
2207  {
2208  *(ElementType*)CFX_BaseSegmentedArray::Add() = data;
2209  }
2210 
2218  ElementType& operator [] (int index)
2219  {
2220  return *(ElementType*)CFX_BaseSegmentedArray::GetAt(index);
2221  }
2222 };
2223 
2227 template <class DataType, int FixedSize>
2228 class CFX_FixedBufGrow : public CFX_Object
2229 {
2230  public:
2238  : m_pAllocator(pAllocator)
2239  , m_pData(NULL)
2240  {
2241  FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2242  }
2243 
2251  CFX_FixedBufGrow(int data_size, IFX_Allocator* pAllocator = NULL)
2252  : m_pAllocator(pAllocator)
2253  , m_pData(NULL)
2254  {
2255  if (data_size > FixedSize)
2256  m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
2257  else
2258  FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2259  }
2260  //<<<+++OPENSOURCE_END
2261 
2269  void SetDataSize(int data_size) {
2270  if (m_pData)
2271  FX_Allocator_Free(m_pAllocator, m_pData);
2272  m_pData = NULL;
2273  if (data_size > FixedSize)
2274  m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
2275  else {
2276  FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
2277  }
2278  }
2279 
2283  ~CFX_FixedBufGrow() { if (m_pData) FX_Allocator_Free(m_pAllocator, m_pData); }
2284 
2285  operator DataType*() { return m_pData ? m_pData : m_Data; }
2286 
2287  private:
2288  IFX_Allocator* m_pAllocator;
2289 
2290  DataType m_Data[FixedSize];
2291  DataType* m_pData;
2292 };
2293 
2297 template <class DataType>
2299 {
2300  public:
2308  CFX_TempBuf(int size, IFX_Allocator* pAllocator = NULL) : m_pAllocator(pAllocator)
2309  {
2310  m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, size);
2311  }
2312 
2317  {
2318  if (m_pData) FX_Allocator_Free(m_pAllocator, m_pData);
2319  }
2320  //<<<+++OPENSOURCE_END
2321 
2322  DataType& operator[](int i) { FXSYS_assert(m_pData != NULL); return m_pData[i]; }
2323  operator DataType*() const { return m_pData; }
2324 
2325  private:
2326  IFX_Allocator* m_pAllocator;
2327 
2328  DataType* m_pData;
2329 };
2330 
2331 //*****************************************************************************
2332 //* Map
2333 //*****************************************************************************
2334 
2338 class CFX_MapPtrToPtr : public CFX_Object
2339 {
2340  protected:
2344  struct CAssoc
2345  {
2349  void* key;
2351  void* value;
2352  };
2353 
2354  public:
2362  CFX_MapPtrToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
2363  //<<<+++OPENSOURCE_END
2364 
2368  ~CFX_MapPtrToPtr();
2369 
2375  int GetCount() const { return m_nCount; }
2376 
2382  FX_BOOL IsEmpty() const { return m_nCount == 0; }
2383 
2392  FX_BOOL Lookup(void* key, void*& rValue) const;
2393 
2401  void* GetValueAt(void* key) const;
2402 
2410  void*& operator[](void* key);
2411 
2420  void SetAt(void* key, void* newValue) { (*this)[key] = newValue; }
2421 
2429  FX_BOOL RemoveKey(void* key);
2430 
2436  void RemoveAll();
2437 
2443  FX_POSITION GetStartPosition() const { return (m_nCount == 0) ? NULL : (FX_POSITION)-1; }
2444 
2457  void GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void*& rValue) const;
2458 
2464  FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
2465 
2475  void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = true);
2476 
2477  protected:
2478  /* Special allocator pointer. NULL to use default allocator. */
2479  IFX_Allocator* m_pAllocator;
2480 
2481  /* The hash table. */
2482  CAssoc** m_pHashTable;
2483  /* The size of hash table. */
2484  FX_DWORD m_nHashTableSize;
2485  /* The number of key-value pair in the map. */
2486  int m_nCount;
2487  /* The freed association list internal. */
2488  CAssoc* m_pFreeList;
2489  /* The block list internal. */
2490  struct CFX_Plex* m_pBlocks;
2491  /* The size in associations of each block. */
2492  int m_nBlockSize;
2493 
2494  /*
2495  * Routine used to user-provided hash keys.
2496  *
2497  * @note Overwrite-able: special non-virtual (see map implementation for details).
2498  *
2499  * @param[in] key The key used to produce hash key.
2500  * @return A hash value.
2501  */
2502  FX_DWORD HashKey(void* key) const;
2503 
2504  /*
2505  * Allocate a new association.
2506  *
2507  * @return The pointer to the new allocated association.
2508  */
2509  CAssoc* NewAssoc();
2510  /*
2511  * Free an association.
2512  *
2513  * @param[in] pAssoc A pointer to an association.
2514  */
2515  void FreeAssoc(CAssoc* pAssoc);
2516  /*
2517  * @brief Retrieve an association by a key.
2518  *
2519  * @param[in] key The input key.
2520  * @param[out] hash The hash value computed.
2521  *
2522  * @return Current association object.
2523  */
2524  CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
2525  /*
2526  * @brief Retrieve current association by position.
2527  *
2528  * @param[in, out] rNextPosition Input a position, and receive the next association position.
2529  *
2530  * @return Current association object.
2531  */
2532  CAssoc* GetCurrentAssoc(FX_POSITION& rNextPosition) const;
2533  /*
2534  * @brief Expand 2 times HashTable Size than before.
2535  *
2536  * @details The MaxHashTableSize is 10000.
2537  *
2538  * @return <b>true</b> means success, while <b>false</b> means failure.
2539  */
2540  FX_BOOL ExpandHashTable();
2541  private:
2542  CFX_MapPtrToPtr(const CFX_MapPtrToPtr &) FX_EQDELETE;
2543  CFX_MapPtrToPtr &operator=(const CFX_MapPtrToPtr &) FX_EQDELETE;
2544 };
2545 
2549 template <class KeyType, class ValueType>
2551 {
2552  public:
2558  CFX_MapPtrTemplate(IFX_Allocator* pAllocator = NULL) : CFX_MapPtrToPtr(10, pAllocator) {}
2559 
2568  FX_BOOL Lookup(KeyType key, ValueType& rValue) const
2569  {
2570  FX_LPVOID pValue = NULL;
2571  if (!CFX_MapPtrToPtr::Lookup((void*)(FX_UINTPTR)key, pValue))
2572  return false;
2573  rValue = (ValueType)(FX_UINTPTR)pValue;
2574  return true;
2575  }
2576 
2584  ValueType& operator[](KeyType key) { return (ValueType&)CFX_MapPtrToPtr::operator []((void*)(FX_UINTPTR)key); }
2585 
2594  void SetAt(KeyType key, ValueType newValue) { CFX_MapPtrToPtr::SetAt((void*)(FX_UINTPTR)key, (void*)(FX_UINTPTR)newValue); }
2595 
2603  FX_BOOL RemoveKey(KeyType key) { return CFX_MapPtrToPtr::RemoveKey((void*)(FX_UINTPTR)key); }
2604 
2614  void GetNextAssoc(FX_POSITION& rNextPosition, KeyType& rKey, ValueType& rValue) const
2615  {
2616  void* pKey = NULL; void* pValue = NULL;
2617  CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
2618  rKey = (KeyType)(FX_UINTPTR)pKey; rValue = (ValueType)(FX_UINTPTR)pValue;
2619  }
2620  private:
2621  CFX_MapPtrTemplate(const CFX_MapPtrTemplate &) FX_EQDELETE;
2622  CFX_MapPtrTemplate &operator=(const CFX_MapPtrTemplate &) FX_EQDELETE;
2623 };
2624 
2629 class CFX_CMapDWordToDWord : public CFX_Object
2630 {
2631  public:
2637  CFX_CMapDWordToDWord(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) {}
2638 
2647  FX_BOOL Lookup(FX_DWORD key, FX_DWORD& value) const;
2648 
2657  void SetAt(FX_DWORD key, FX_DWORD value);
2658 
2667  void EstimateSize(FX_DWORD size, FX_DWORD grow_by);
2668 
2674  FX_POSITION GetStartPosition() const;
2675 
2685  void GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;
2686 
2692  void RemoveAll() { m_Buffer.Clear(); }
2693 
2694  protected:
2697  private:
2698  CFX_CMapDWordToDWord(const CFX_CMapDWordToDWord &) FX_EQDELETE;
2699  CFX_CMapDWordToDWord &operator=(const CFX_CMapDWordToDWord &) FX_EQDELETE;
2700 };
2701 
2703 class CFX_MapByteStringToPtr : public CFX_Object
2704 {
2705  protected:
2709  struct CAssoc
2710  {
2713 
2719  void* value;
2720  };
2721 
2722  public:
2730  CFX_MapByteStringToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
2731 
2737  int GetCount() const { return m_nCount; }
2738 
2744  FX_BOOL IsEmpty() const { return m_nCount == 0; }
2745 
2754  FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;
2755 
2763  void*& operator[](FX_BSTR key);
2764 
2773  void SetAt(FX_BSTR key, void* newValue) { (*this)[key] = newValue; }
2774 
2782  FX_BOOL RemoveKey(FX_BSTR key);
2783 
2789  void RemoveAll();
2790 
2796  FX_POSITION GetStartPosition() const { return (m_nCount == 0) ? NULL : (FX_POSITION)-1; }
2797 
2807  void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
2808 
2816  FX_LPVOID GetNextValue(FX_POSITION& rNextPosition) const;
2817 
2823  FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
2824 
2834  void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = true);
2835 
2845  FX_DWORD HashKey(FX_BSTR key) const;
2846 
2847  protected:
2848  /* Special allocator pointer. NULL to use default allocator. */
2849  IFX_Allocator* m_pAllocator;
2850 
2851  /* The hash table. */
2852  CAssoc** m_pHashTable;
2853  /* The size of hash table. */
2854  FX_DWORD m_nHashTableSize;
2855  /* The number of key-value pair in the map. */
2856  int m_nCount;
2857  /* The freed association list internal. */
2858  CAssoc* m_pFreeList;
2859  /* The block list internal. */
2860  struct CFX_Plex* m_pBlocks;
2861  /* The size in associations of each block. */
2862  int m_nBlockSize;
2863 
2864  /*
2865  * @brief Allocate a new association.
2866  *
2867  * @return The pointer to the new allocated association.
2868  */
2869  CAssoc* NewAssoc();
2870  /*
2871  * @brief Free an association.
2872  *
2873  * @param[in] pAssoc A pointer to an association.
2874  *
2875  * @return None.
2876  */
2877  void FreeAssoc(CAssoc* pAssoc);
2878  /*
2879  * @brief Retrieve an association by a key.
2880  *
2881  * @param[in] key The input key.
2882  * @param[out] hash The hash value computed.
2883  *
2884  * @return An association object.
2885  */
2886  CAssoc* GetAssocAt(FX_BSTR key, FX_DWORD& hash) const;
2887  /*
2888  * @brief Retrieve current association by position.
2889  *
2890  * @param[in] rNextPosition The current position.
2891  *
2892  * @return An association object.
2893  */
2894  CAssoc* GetCurrentAssoc(FX_POSITION& rNextPosition) const;
2895  /*
2896  * @brief Expand 2 times HashTable Size than before.
2897  *
2898  * @details The MaxHashTableSize is 10000.
2899  *
2900  * @return <b>true</b> means success, while <b>false</b> means failure.
2901  */
2902  FX_BOOL ExpendHashTable();
2903 
2904  public:
2907 };
2908 
2917 class CFX_CMapByteStringToPtr : public CFX_Object
2918 {
2919  public:
2926  //<<<+++OPENSOURCE_END
2927 
2930 
2936  void RemoveAll();
2937 
2943  FX_POSITION GetStartPosition() const;
2944 
2954  void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
2955 
2963  FX_LPVOID GetNextValue(FX_POSITION& rNextPosition) const;
2964 
2973  FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;
2974 
2983  void SetAt(FX_BSTR key, void* value);
2984 
2992  void RemoveKey(FX_BSTR key);
2993 
2999  int GetCount() const;
3000 
3012  void AddValue(FX_BSTR key, void* pValue);
3013 
3014  protected:
3015  /* A chained buffer storing keys and values. */
3016  CFX_BaseSegmentedArray m_Buffer;
3017 };
3018 
3020 // Lists
3022 
3024 class CFX_PtrList : public CFX_Object
3025 {
3026  protected:
3028  struct CNode
3029  {
3035  void* data;
3036  };
3037 
3038  public:
3045  CFX_PtrList(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
3046  //<<<+++OPENSOURCE_END
3047 
3053  FX_POSITION GetHeadPosition() const { return (FX_POSITION)m_pNodeHead; }
3054 
3060  FX_POSITION GetTailPosition() const { return (FX_POSITION)m_pNodeTail; }
3061 
3069  void* GetNext(FX_POSITION& rPosition) const
3070  {
3071  CNode* pNode = (CNode*)rPosition; rPosition = (FX_POSITION)pNode->pNext; return pNode->data;
3072  }
3073 
3081  void* GetPrev(FX_POSITION& rPosition) const
3082  {
3083  CNode* pNode = (CNode*)rPosition; rPosition = (FX_POSITION)pNode->pPrev; return pNode->data;
3084  }
3085 
3093  FX_POSITION GetNextPosition(FX_POSITION pos) const { return ((CNode*)pos)->pNext; }
3094 
3102  FX_POSITION GetPrevPosition(FX_POSITION pos) const { return ((CNode*)pos)->pPrev; }
3103 
3111  void* GetAt(FX_POSITION rPosition) const
3112  {
3113  CNode* pNode = (CNode*)rPosition; return pNode ? pNode->data : NULL;
3114  }
3115 
3121  int GetCount() const { return m_nCount; }
3122 
3130  FX_POSITION AddTail(void* newElement);
3131 
3139  FX_POSITION AddHead(void* newElement);
3140 
3149  void SetAt(FX_POSITION pos, void* newElement)
3150  {
3151  CNode* pNode = (CNode*)pos; pNode->data = newElement;
3152  }
3153 
3162  FX_POSITION InsertAfter(FX_POSITION pos, void* newElement);
3163 
3172  FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL ) const;
3173 
3181  FX_POSITION FindIndex(int index) const;
3182 
3190  void RemoveAt(FX_POSITION pos);
3191 
3197  void RemoveAll();
3198 
3199  protected:
3200  /* Special allocator pointer. <b>NULL</b> means to use default allocator. */
3201  IFX_Allocator* m_pAllocator;
3202 
3203  /* Pointer to the head. */
3204  CNode* m_pNodeHead;
3205  /* Pointer to the tail. */
3206  CNode* m_pNodeTail;
3207  /* The count of nodes in the list. */
3208  int m_nCount;
3209  /* The freed node list internal. */
3210  CNode* m_pNodeFree;
3211  /* The block list internal. */
3212  struct CFX_Plex* m_pBlocks;
3213  /* The size in nodes of each block. */
3214  int m_nBlockSize;
3215 
3216  /*
3217  * Allocate a new node.
3218  *
3219  * @param[in] pPrev The pointer to the previous node.
3220  * @param[in] pNext The pointer to the next node.
3221  *
3222  * @return The pointer to the new node.
3223  */
3224  CNode* NewNode(CNode* pPrev, CNode* pNext);
3225  /*
3226  * Free a node.
3227  *
3228  * @param[in] pNode The node pointer.
3229  */
3230  void FreeNode(CNode* pNode);
3231 
3232  public:
3234  ~CFX_PtrList();
3235 };
3236 
3237 //*****************************************************************************
3238 //* Utilities
3239 //*****************************************************************************
3240 
3244 typedef void (*PD_CALLBACK_FREEDATA)(FX_LPVOID pData);
3245 
3250 {
3256  void FreeData();
3257 
3260 
3263 
3266 
3272 };
3273 
3278 {
3279  public:
3285  CFX_PrivateData(IFX_Allocator* pAllocator = NULL) : m_DataList(pAllocator) {}
3286 
3288  ~CFX_PrivateData();
3289 
3295  void ClearAll();
3296 
3313  void SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback);
3314 
3327  void SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject* pObj);
3328 
3339  FX_LPVOID GetPrivateData(FX_LPVOID module_id);
3340 
3350  {
3351  if (!module_id) return false;
3352  FX_DWORD nCount = m_DataList.GetSize();
3353  for (FX_DWORD n = 0; n < nCount; n++) {
3354  if (m_DataList[n].m_pModuleId == module_id) {
3355  pData = m_DataList[n].m_pData;
3356  return true;
3357  }
3358  }
3359  return false;
3360  }
3361 
3371  FX_BOOL RemovePrivateData(FX_LPVOID module_id);
3372 
3373  protected:
3374  /* Private data array. */
3376  /*
3377  * Add a private data. Add if not exist, otherwise modify.
3378  *
3379  * @param[in] module_id The module id.
3380  * @param[in] pData The private data.
3381  * @param[in] callback The callback function for deallocating provided private data.
3382  * @param[in] bSelfDestruct Whether the private data is a CFX_DestructObject derived object actually.
3383  *
3384  * @return None.
3385  */
3386  void AddData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct);
3387 };
3388 
3393 class CFX_BitStream : public CFX_Object
3394 {
3395  public:
3404  void Init(FX_LPCBYTE pData, FX_DWORD dwSize);
3405 
3413  FX_DWORD GetBits(FX_DWORD nBits);
3414 
3420  void ByteAlign();
3421 
3427  FX_BOOL IsEOF() const { return m_BitPos >= m_BitSize; }
3428 
3436  void SkipBits(FX_DWORD nBits) { m_BitPos += nBits; }
3437 
3443  void Rewind() { m_BitPos = 0; }
3444 
3445  protected:
3446  /* Bit position (zero-based). */
3447  FX_DWORD m_BitPos;
3448  /* Total bit counts in the memory block. */
3449  FX_DWORD m_BitSize;
3450  /* bit-stream stream buffer. */
3451  FX_LPCBYTE m_pData;
3452 };
3453 
3457 class CFX_BitWriter : public CFX_Object
3458 {
3459  public:
3465  CFX_BitWriter(CFX_BinaryBuf* pBinBuf) :m_pBinBuf(pBinBuf), m_BitPos(0), m_BytePos(0) {}
3466 
3475  void WriteBits(FX_INT64 value, FX_INT32 nBits);
3476 
3482  void ByteAlign();
3483 
3489  int GetCurBytePos() { return m_BytePos; }
3490 
3491  protected:
3492  /* Dynamic binary buffer. */
3493  CFX_BinaryBuf * m_pBinBuf;
3494  /* Bit position (zero-based). */
3495  int m_BitPos;
3496  /* Byte position (zero-based). */
3497  int m_BytePos;
3498 };
3499 
3504 template <class ObjClass> class CFX_CountRef : public CFX_Object
3505 {
3506  public:
3509 
3513  class CountedObj : public ObjClass
3514  {
3515  public:
3518 
3524  CountedObj(const CountedObj& src) : ObjClass(src) ,m_RefCount(0){}
3525 
3528  };
3529 
3534  {
3535  m_pObject = NULL;
3536  }
3537 
3543  CFX_CountRef(const Ref& ref)
3544  {
3545  m_pObject = ref.m_pObject;
3546  if (m_pObject) m_pObject->m_RefCount ++;
3547  }
3548 
3553  {
3554  if (!m_pObject) return;
3555  m_pObject->m_RefCount --;
3556  if (m_pObject->m_RefCount <= 0) {
3557  delete m_pObject;
3558  m_pObject = NULL;
3559  }
3560  }
3561 
3568  ObjClass* New()
3569  {
3570  if (m_pObject) {
3571  m_pObject->m_RefCount --;
3572  if (m_pObject->m_RefCount <= 0)
3573  delete m_pObject;
3574  m_pObject = NULL;
3575  }
3576  m_pObject = FX_NEW CountedObj;
3577  if (!m_pObject) return NULL;
3578  m_pObject->m_RefCount = 1;
3579  return m_pObject;
3580  }
3581 
3589  void operator = (const Ref& ref)
3590  {
3591  if (ref.m_pObject)
3592  ref.m_pObject->m_RefCount ++;
3593  if (m_pObject) {
3594  m_pObject->m_RefCount --;
3595  if (m_pObject->m_RefCount <= 0)
3596  delete m_pObject;
3597  }
3598  m_pObject = ref.m_pObject;
3599  }
3600 
3608  void operator = (void* p)
3609  {
3610  FXSYS_assert(p == 0);
3611  if (m_pObject == NULL) return;
3612  m_pObject->m_RefCount --;
3613  if (m_pObject->m_RefCount <= 0)
3614  delete m_pObject;
3615  m_pObject = NULL;
3616  }
3617 
3618 #if defined(_FX_MANAGED_CODE_) && defined(GetObject)
3619  #undef GetObject
3620 #endif
3621 
3626  const ObjClass* GetObject() const
3627  {
3628  return m_pObject;
3629  }
3635  operator const ObjClass*() const
3636  {
3637  return m_pObject;
3638  }
3639 
3645  FX_BOOL IsNull() const
3646  {
3647  return m_pObject == NULL;
3648  }
3655  {
3656  return m_pObject != NULL;
3657  }
3658 
3667  ObjClass* GetModify()
3668  {
3669  if (m_pObject == NULL) {
3670  m_pObject = FX_NEW CountedObj;
3671  if (m_pObject)
3672  m_pObject->m_RefCount = 1;
3673  } else if (m_pObject->m_RefCount > 1) {
3674  m_pObject->m_RefCount --;
3675  CountedObj* pOldObject = m_pObject;
3676  m_pObject = NULL;
3677  m_pObject = FX_NEW CountedObj(*pOldObject);
3678  if (m_pObject)
3679  m_pObject->m_RefCount = 1;
3680  }
3681  return m_pObject;
3682  }
3683 
3689  void SetNull()
3690  {
3691  if (m_pObject == NULL) return;
3692  m_pObject->m_RefCount --;
3693  if (m_pObject->m_RefCount <= 0)
3694  delete m_pObject;
3695  m_pObject = NULL;
3696  }
3697 
3705  FX_BOOL operator == (const Ref& ref) const
3706  {
3707  return m_pObject == ref.m_pObject;
3708  }
3709 
3715  int RefCount() const
3716  {
3717  return m_pObject ? m_pObject->m_RefCount : 0;
3718  }
3719 
3725  void Incref()
3726  {
3727  if (m_pObject == NULL) return;
3728  m_pObject->m_RefCount++;
3729  }
3730 
3736  void Decref()
3737  {
3738  if (m_pObject == NULL) return;
3739  m_pObject->m_RefCount--;
3740  if (m_pObject->m_RefCount <= 0) {
3741  delete m_pObject;
3742  m_pObject = NULL;
3743  }
3744  }
3745 
3746  protected:
3747  /* Reference counted object internal. */
3748  CountedObj* m_pObject;
3749 };
3750 
3753 {
3754  public:
3756  virtual ~IFX_Pause() {}
3757 
3763  virtual FX_BOOL NeedToPauseNow() = 0;
3764 };
3765 
3767 class CFX_DataFilter : public CFX_Object
3768 {
3769  public:
3773  virtual ~CFX_DataFilter();
3774 
3782  void SetDestFilter(CFX_DataFilter* pFilter);
3783 
3789  FX_BOOL IsEOF() const { return m_bEOF; }
3790 
3796  FX_FILESIZE GetSrcPos() const { return m_SrcPos; }
3797 
3807  void FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf& dest_buf);
3808 
3817  void FilterFinish(CFX_BinaryBuf& dest_buf);
3818 
3824  FX_BOOL IsExhaustBuffer() const { return m_bExhaustBuffer; }
3825 
3831  FX_BOOL NeedNewSrc();
3832 
3838  FX_BOOL Abort() const { return m_bAbort; }
3839 
3845  FX_BOOL AbortAll();
3846 
3852  void ResetStatistics();
3853 
3854  protected:
3855  /* The constructor. */
3856  CFX_DataFilter();
3857 
3858  virtual void v_FilterIn(FX_LPCBYTE src_buf, size_t src_size, CFX_BinaryBuf& dest_buf) = 0;
3859  virtual void v_FilterFinish(CFX_BinaryBuf& dest_buf) = 0;
3860  virtual void v_ResetStatistics() {};
3861  void ReportEOF(FX_FILESIZE left_input);
3862 
3863  /* Indicate whether we met the EOF. */
3864  FX_BOOL m_bEOF;
3865  /* Current position in the source stream. */
3866  FX_FILESIZE m_SrcPos;
3867  /* Filter chain. */
3868  CFX_DataFilter* m_pDestFilter;
3869 
3870  /* Indicate whether this filter exhausts the input buffer. */
3871  FX_BOOL m_bExhaustBuffer;
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 };
3878 
3880 template<typename T>
3882  public:
3888  explicit CFX_AutoRestorer(T* location) {
3889  m_Location = location;
3890  m_OldValue = *location;
3891  }
3892 
3894  ~CFX_AutoRestorer() { *m_Location = m_OldValue; }
3895  private:
3896  T* m_Location;
3897  T m_OldValue;
3898 };
3899 
3901 template <class T>
3903 {
3904  public:
3910  CFX_SmartPointer(T *pObj) : m_pObj(pObj) {}
3911 
3913  ~CFX_SmartPointer() {m_pObj->Release();}
3914 
3920  T* Get(void) {return m_pObj;}
3921 
3927  T& operator *(void) {return *m_pObj;}
3928 
3934  T* operator ->(void) {return m_pObj;}
3935 
3936  protected:
3937  T *m_pObj;
3938 };
3939 
3940 #define FX_DATALIST_LENGTH 1024
3941 
3943 template<size_t unit>
3944 class CFX_SortListArray : public CFX_Object
3945 {
3946  protected:
3948  struct DataList {
3953  FX_LPBYTE data;
3954  DataList()
3955  {
3956  start = count = 0;
3957  data = NULL;
3958  }
3959  };
3960 
3961  public:
3967  CFX_SortListArray(IFX_Allocator* pAllocator = NULL) : m_CurList(0), m_DataLists(pAllocator) {}
3968 
3971  {
3972  Clear();
3973  }
3974 
3980  void Clear()
3981  {
3982  IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
3983 
3984  for (FX_INT32 i = m_DataLists.GetUpperBound(); i >= 0; i--){
3985  DataList list = m_DataLists.ElementAt(i);
3986  if (list.data) FX_Allocator_Free(pAllocator, list.data);
3987  }
3988  m_DataLists.RemoveAll();
3989  m_CurList = 0;
3990  }
3991 
4000  void Append(FX_INT32 nStart, FX_INT32 nCount)
4001  {
4002  if (nStart < 0) return;
4003 
4004  IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
4005 
4006  while (nCount > 0){
4007  FX_INT32 temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
4008  DataList list;
4009 
4010  list.data = FX_Allocator_Alloc(pAllocator, FX_BYTE, temp_count * unit);
4011  if (!list.data) break;
4012  FXSYS_memset32(list.data, 0, temp_count * unit);
4013  list.start = nStart;
4014  list.count = temp_count;
4015 
4016  FX_BOOL ret = Append(list);
4017  if(ret)
4018  {
4019  nCount -= temp_count;
4020  nStart += temp_count;
4021  }
4022  else
4023  {
4024  if (list.data) FX_Allocator_Free(pAllocator, list.data);
4025  return;
4026  }
4027  }
4028  }
4029 
4038  {
4039  if (nIndex < 0) return NULL;
4040  if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) return NULL;
4041  DataList *pCurList = m_DataLists.GetDataPtr(m_CurList);
4042  if (!pCurList || nIndex < pCurList->start || nIndex >= pCurList->start + pCurList->count){
4043  pCurList = NULL;
4044  FX_INT32 iStart = 0;
4045  FX_INT32 iEnd = m_DataLists.GetUpperBound();
4046  while (iStart <= iEnd){
4047  FX_INT32 iMid = (iStart + iEnd) / 2;
4048  DataList* list = m_DataLists.GetDataPtr(iMid);
4049  if (nIndex < list->start)
4050  iEnd = iMid - 1;
4051  else if (nIndex >= list->start + list->count)
4052  iStart = iMid + 1;
4053  else {
4054  pCurList = list;
4055  m_CurList = iMid;
4056  break;
4057  }
4058  }
4059  }
4060  return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;
4061  }
4062 
4063  protected:
4064  FX_BOOL Append(const DataList& list)
4065  {
4066  FX_INT32 iStart = 0;
4067  FX_INT32 iEnd = m_DataLists.GetUpperBound();
4068  FX_INT32 iFind = 0;
4069  while (iStart <= iEnd) {
4070  FX_INT32 iMid = (iStart + iEnd) / 2;
4071  DataList* cur_list = m_DataLists.GetDataPtr(iMid);
4072  if (list.start == cur_list->start){
4073  return false; // lists overlap, no op
4074  } else if (list.start < cur_list->start + cur_list->count)
4075  iEnd = iMid - 1;
4076  else{
4077  if (iMid == iEnd){
4078  iFind = iMid + 1;
4079  break;
4080  }
4081  DataList* next_list = m_DataLists.GetDataPtr(iMid + 1);
4082  if (list.start == next_list->start){
4083  return false; // lists overlap, no op
4084  } else if (list.start < next_list->start){
4085  iFind = iMid + 1;
4086  break;
4087  } else {
4088  iStart = iMid + 1;
4089  }
4090  }
4091  }
4092  m_DataLists.InsertAt(iFind, list);
4093  return true;
4094  }
4095 
4096  FX_INT32 m_CurList;
4097  CFX_ArrayTemplate<DataList> m_DataLists;
4098 };
4099 
4101 template<typename T1, typename T2>
4102 class CFX_ListArrayTemplate : public CFX_Object
4103 {
4104  public:
4110  void Clear()
4111  {
4112  m_Data.Clear();
4113  }
4114 
4123  void Add(FX_INT32 nStart, FX_INT32 nCount)
4124  {
4125  m_Data.Append(nStart, nCount);
4126  }
4127 
4136  {
4137  FX_LPBYTE data = m_Data.GetAt(nIndex);
4138  FXSYS_assert(data != NULL);
4139 
4140  return (T2&)(*(volatile T2*)data);
4141  }
4142 
4150  T2* GetPtrAt(FX_INT32 nIndex)
4151  {
4152  return (T2*)m_Data.GetAt(nIndex);
4153  }
4154  protected:
4155  T1 m_Data;
4156 };
4157 
4162 
4168 typedef enum {
4182 
4183 #define ProgressiveStatus FX_ProgressiveStatus
4184 
4185 #ifdef _FX_NO_NAMESPACE_
4186 //<<<+++OPENSOURCE_BEGIN LIC==FOXIT
4187 #define FX_NAMESPACE_DECLARE(namespace, type) type
4188 //<<<+++OPENSOURCE_END
4189 #else
4190 //<<<+++OPENSOURCE_BEGIN LIC==GOOGLE
4191 #define FX_NAMESPACE_DECLARE(namespace, type) namespace::type
4192 //<<<+++OPENSOURCE_END
4193 #endif
4194 
4197 {
4198  public:
4204  virtual FX_DWORD Release() = 0;
4205 
4211  virtual FX_DWORD AddRef() = 0;
4212 
4213  protected:
4214  virtual ~IFX_Unknown() {}
4215 };
4216 
4218 #define FX_IsOdd(a) ((a) & 1)
4219 
4220 //<<<+++OPENSOURCE_MUST_END
4221 
4222 //<<<+++OPENSOURCE_MUST_BEGIN
4223 #endif // _FX_BASIC_H_
4224 //<<<+++OPENSOURCE_MUST_END
4225 
4228 //<<<+++OPENSOURCE_END
Definition: fx_basic.h:3767
void GetNextAssoc(FX_POSITION &rNextPosition, CFX_ByteString &rKey, void *&rValue) const
Get the current association and set the position to next association.
void SetAt(FX_BSTR key, void *newValue)
Add a new (key, value) pair. Add if not exist, otherwise modify.
Definition: fx_basic.h:2773
FX_POSITION GetStartPosition() const
Get the first key-value pair position. iterating all (key, value) pairs.
Definition: fx_basic.h:3277
CFX_WideTextBuf & operator<<(int i)
Left shifts(<<) operator overload. Output a integer to the wide text buffer.
CNode * pNext
Pointer to next node.
Definition: fx_basic.h:3031
CFX_WideStringC GetResult() const
Get the result.
Definition: fx_basic.h:1051
void * FX_LPVOID
Pointer to any type.
Definition: fx_system.h:632
void RemoveAll()
Remove all the (key, value) pairs in the map.
Dynamic binary buffers designed for more efficient appending.
Definition: fx_basic.h:52
Definition: fx_basic.h:2066
Definition: fx_basic.h:4196
Ready.
Definition: fx_basic.h:4170
~CFX_MapByteStringToPtr()
The destructor.
T2 & operator [](FX_INT32 nIndex)
Subscript([]) operator overload.
Definition: fx_basic.h:4135
void Add(const ObjectClass &data)
Add a copy of an existing object to the array.
Definition: fx_basic.h:1685
Header file for Streams related definitions and classes.
wchar_t FX_WCHAR
Compiler dependant Unicode character (16-bit for Microsoft Compiler, 32-bit for gcc).
Definition: fx_system.h:708
Bidirectional node in CFX_PtrList.
Definition: fx_basic.h:3028
FX_LPVOID m_pModuleId
Module ID.
Definition: fx_basic.h:3259
CFX_ByteStringC GetResult() const
Get the result.
Definition: fx_basic.h:1107
TYPE & operator[](int nIndex)
Subscript([]) operator overload. This function returns a reference to the specified element specified...
Definition: fx_basic.h:1549
unsigned long FX_DWORD
32-bit unsigned integer.
Definition: fx_system.h:702
Definition: fx_basic.h:1074
FX_BOOL RemovePrivateData(FX_LPVOID module_id)
Remove previously stored private data. FPDFAPI assumes the module has deallocated the data,...
FX_BOOL AppendChar(FX_WCHAR wch)
Append a single wide character.
int Size() const
Get size of the container.
Definition: fx_basic.h:2022
FX_BOOL IsEmpty() const
Verify whether the map is empty.
Definition: fx_basic.h:2382
FX_POSITION InsertAfter(FX_POSITION pos, void *newElement)
Insert a value after specified position.
CONSTANT WIDE STRING CLASS.
Definition: fx_string.h:1205
Not Found.
Definition: fx_basic.h:4176
Association in CFX_MapByteStringToPtr.
Definition: fx_basic.h:2709
IFX_Allocator * m_pAllocator
Special allocator pointer. NULL to use default allocator.
Definition: fx_basic.h:1171
void Incref()
Increase the reference.
Definition: fx_basic.h:3725
void Delete(int index, int count=1)
Delete a number of elements.
Definition: fx_basic.h:1860
~CFX_ObjectArray()
The destructor.
Definition: fx_basic.h:1649
void GetNextAssoc(FX_POSITION &rNextPosition, void *&rKey, void *&rValue) const
Get the current association and set the position to next association.
#define FX_Allocator_Alloc(fxAllocator, type, size)
Release-mode allocation on an allocator.
Definition: fx_memory.h:1050
FX_STRSIZE GetLength() const
Get the length of the byte string.
Definition: fx_string.h:227
CFX_ArrayTemplate< FX_DWORD > CFX_DWordArray
Type definition for a double-word array type.
Definition: fx_basic.h:1615
TYPE & ElementAt(int nIndex)
This method retrieves a ref to an element specified by an index number.
Definition: fx_basic.h:1416
CFX_ObjectArray(const CFX_ObjectArray &other, IFX_Allocator *pAllocator=0)
The copy constructor.
Definition: fx_basic.h:1657
void AddValue(FX_BSTR key, void *pValue)
Add a key-value pair to the dictionary, assuming there is no duplicated key existing.
T2 * GetPtrAt(FX_INT32 nIndex)
Get a point to data.
Definition: fx_basic.h:4150
void Push(const CFX_ByteString &val)
Push the byte string to stack.
Definition: fx_basic.h:2054
CFX_ArrayTemplate< FX_WORD > CFX_WordArray
Type definition for a word array type.
Definition: fx_basic.h:1613
void RemoveAll()
Remove all nodes in the list.
int GetCount() const
Get the number of key-value pairs.
CFX_ByteTextBuf & operator<<(int i)
Left shifts(<<) operator overload. Output an integer to the byte text buffer.
FX_BOOL IsNull() const
Check if the pointer of the object is NULL.
Definition: fx_basic.h:3645
ElementType & operator [](int index)
Subscript([]) operator overload. This function returns a ref to the specified element specified by th...
Definition: fx_basic.h:2218
CFX_FixedBufGrow(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:2237
void * data
Node data.
Definition: fx_basic.h:3035
void SetAt(FX_DWORD key, FX_DWORD value)
Add a new (key, value) pair. Add if not exist, otherwise modify.
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...
FX_BOOL Empty() const
Empty the container.
Definition: fx_basic.h:1946
void Init(FX_LPCBYTE pData, FX_DWORD dwSize)
Initialize the bit-stream with a memory block. Must call Init() first.
CFX_ByteString key
Key data.
Definition: fx_basic.h:2717
void SetAt(KeyType key, ValueType newValue)
Add a new (key, value) pair. Add if not exist, otherwise modify.
Definition: fx_basic.h:2594
FX_POSITION GetStartPosition() const
Get the first key-value pair position. iterating all (key, value) pairs.
Definition: fx_basic.h:2796
FX_INT32(* m_GetCodePage)()
A pointer type to GetCodePage function. The function return a code page of the platform.
Definition: fx_basic.h:993
void GetByteStringL(CFX_ByteStringL &str) const
Get a byte string from current buffer object.
CFX_BinaryBuf(IFX_Allocator *pAllocator=0)
A default constructor creating an empty buffer.
void SetAt(void *key, void *newValue)
Add a new (key, value) pair. Add if not exist, otherwise modify.
Definition: fx_basic.h:2420
void(* PD_CALLBACK_FREEDATA)(FX_LPVOID pData)
Definition: fx_basic.h:3244
wchar_t const * FX_LPCWSTR
Pointer to constant Unicode characters.
Definition: fx_system.h:712
CFX_ObjectArray & operator=(const CFX_ObjectArray &other)
The assignment operator.
Definition: fx_basic.h:1670
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:3271
void * Add()
Add an element.
#define GetObject
Get object information. GetObjectW defined for unicode-mode, GetObjectA for ansi-mode.
Definition: fx_system.h:540
FX_LPVOID m_pData
Private data.
Definition: fx_basic.h:3262
CFX_WideTextBuf(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:345
FX_BOOL Flush()
Flush internal buffer of the file.
void FilterFinish(CFX_BinaryBuf &dest_buf)
Indicate the input finished. For some filters, there might be some last output generated.
FX_INT32 start
The start index.
Definition: fx_basic.h:3950
CFX_Stack()
Construct.
Definition: fx_basic.h:2005
~CFX_CountRef()
Destruct a reference and release the object it refers to.
Definition: fx_basic.h:3552
void RemoveAt(int index)
Remove an object at specified position.
Definition: fx_basic.h:1831
int GetSize() const
Get number of elements in the array.
Definition: fx_basic.h:2133
int GetCurBytePos()
Get current byte position.
Definition: fx_basic.h:3489
CFX_PtrList(int nBlockSize=10, IFX_Allocator *pAllocator=0)
Construct with block size and allocator.
void Clear()
Clear the decoding status and set the output wide text buffer to be empty.
virtual ~CFX_DataFilter()
The destructor. Destroy this filter and all its chain.
void ByteAlign()
Get to byte boundary. If current bit position is not multiplication of 8, the rest of the current byt...
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.
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.
void ClearAll()
Release all remaining data.
int GetSize() const
Get the number of elements in the array.
Definition: fx_basic.h:1351
FX_BOOL Flush()
Flush internal buffer.
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.
FX_POSITION GetNextPosition(FX_POSITION pos) const
Get the next position.
Definition: fx_basic.h:3093
T & operator *(void)
Get the object reference operator.
Definition: fx_basic.h:3927
Definition: fx_basic.h:765
FX_LPVOID GetPrivateData(FX_LPVOID module_id)
Get previously stored private data. Returns NULL for not stored.
FX_INT32 Copy(const CFX_ObjectArray &src, FX_INT32 nStart=0, FX_INT32 nCount=-1)
Copy from an array.
Definition: fx_basic.h:1768
Definition: fx_basic.h:2184
CFX_UTF8Encoder(IFX_Allocator *pAllocator=0)
A constructor. Set the encoder to initial.
Definition: fx_basic.h:1082
void SetStream(IFX_FileStream *pStream)
Set the attached stream.
Definition: fx_basic.h:630
void operator=(FX_LPCWSTR lpsz)
Assignment(=) operator overload. From a zero terminated wide character string.
CFX_TempBuf(int size, IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:2308
#define FX_MIN(a, b)
A macro that returns the minimum of a and b.
Definition: fx_system.h:801
FX_BOOL Abort() const
Indicate whether to abort the filter process.
Definition: fx_basic.h:3838
FX_BOOL AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover=false)
Attach file.
void GetResult(CFX_ByteStringL &result) const
Get the result.
Definition: fx_basic.h:1116
CFX_CMapDWordToDWord(IFX_Allocator *pAllocator=0)
Constructor with allocator.
Definition: fx_basic.h:2637
int GetUnitSize() const
Get number of bytes for each element.
Definition: fx_basic.h:2147
Definition: fx_basic.h:1935
WIDE STRING CLASS.
Definition: fx_string.h:1452
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(IFX_Allocator *pAllocator=0)
A constructor. Set the decoder to initial.
Definition: fx_basic.h:1012
CFX_CountRef< ObjClass > Ref
Type definition: it is used short for CFX_CountRef<ObjClass>.
Definition: fx_basic.h:3508
CFX_ObjectArray(IFX_Allocator *pAllocator=0)
The constructor.
Definition: fx_basic.h:1644
Stream writing interface.
Definition: fx_stream.h:424
CFX_Stack()
Construct.
Definition: fx_basic.h:1864
virtual FX_DWORD AddRef()=0
Increments reference count.
CFX_MapByteStringToPtr(int nBlockSize=10, IFX_Allocator *pAllocator=0)
Construct with specified block size.
void * FX_POSITION
A value used to denote the position of an element in a collection.
Definition: fx_system.h:636
CFX_PrivateData(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:3285
virtual FX_DWORD Release()=0
Decrements reference count and release the current object.
int GetSegmentSize() const
Get number of elements in each segment.
Definition: fx_basic.h:2140
void Input(FX_WCHAR unicode)
Input a unicode.
FX_INTPTR GetLength() const
Get the length of saved data.
Definition: fx_basic.h:614
Memory allocation error.
Definition: fx_basic.h:1301
FX_LPCBYTE GetBuffer() const
Get the constant byte pointer to the saved data.
Definition: fx_basic.h:621
FX_BOOL Read(void *pBuf, FX_DWORD dwSize)
De-serialize a memory block.
virtual FX_BOOL NeedToPauseNow()=0
Check whether callers need to pause now.
void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow=true)
Initialize the hash table.
ObjectClass & operator[](int index) const
Subscript([]) operator overload. This function returns a reference to the specified object specified ...
Definition: fx_basic.h:1809
FX_BOOL Copy(const CFX_ArrayTemplate &src)
Copy from an array.
Definition: fx_basic.h:1489
FX_BOOL SetSize(int nNewSize, int nGrowBy=-1)
Change the allocated size and the grow amount.
Definition: fx_basic.h:1368
FX_LPCBYTE GetPtr() const
Get a constant byte string pointer to the byte string.
Definition: fx_string.h:215
void Clear()
Set the binary buffer to be empty.
void SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject *pObj)
Set private object.
Definition: fx_basic.h:336
void Clear()
Remove all remaining data from stack.
Definition: fx_basic.h:1923
FX_DWORD HashKey(FX_BSTR key) const
Routine used to user-provided hash keys.
IFX_Allocator * m_pAllocator
Special allocator pointer. NULL means to use default allocator.
Definition: fx_basic.h:229
__int64 FX_INT64
Signed 64-bit integer.
Definition: fx_system.h:716
int m_RefCount
The reference count.
Definition: fx_basic.h:3527
Definition: fx_basic.h:3902
CFX_FileBufferArchive(FX_STRSIZE size=32768, IFX_Allocator *pAllocator=0)
A constructor with size and allocator.
Header file for Strings, variable-length sequence of characters. There are two strings here,...
void * value
Value data.
Definition: fx_basic.h:2351
CFX_MapPtrToPtr(int nBlockSize=10, IFX_Allocator *pAllocator=0)
Construct with specified block size.
FX_INT64 GetSrcPos() const
Get current position in the source stream (byte offset from the beginning of all input data).
Definition: fx_basic.h:3796
FX_BOOL Append(const CFX_ArrayTemplate &src)
Append an array.
Definition: fx_basic.h:1480
FX_BOOL RemoveKey(KeyType key)
Remove existing (key, ?) pair.
Definition: fx_basic.h:2603
T * operator ->(void)
Get the object pointer operator.
Definition: fx_basic.h:3934
int FX_INT32
32-bit signed integer.
Definition: fx_system.h:661
FX_BOOL Lookup(KeyType key, ValueType &rValue) const
Lookup by a key.
Definition: fx_basic.h:2568
void * FXSYS_memset32(void *dst, FX_INT32 v, size_t size)
Set buffer data to specified value.
CFX_CountRef()
Construct a null reference.
Definition: fx_basic.h:3533
int FX_STRSIZE
String size is limited to 2^31-1.
Definition: fx_string.h:35
void RemoveAll()
Clean up the array.
Definition: fx_basic.h:1378
FX_POSITION GetHeadPosition() const
Get the header position.
Definition: fx_basic.h:3053
FX_POSITION GetStartPosition() const
Get the first key-value pair position. iterating all (key, value) pairs.
FX_BOOL Add(TYPE newElement)
Add an element at the tail. Potentially growing the array.
Definition: fx_basic.h:1463
CFX_ArrayTemplate< FX_INT32 > CFX_Int32Array
Type definition for INT32 array.
Definition: fx_basic.h:1623
Definition: fx_basic.h:2917
Definition: fx_basic.h:251
FX_BOOL IsEOF()
Check whether de-serializing is to the end of the loading buffer.
CFX_ByteTextBuf(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:260
Association in CFX_MapPtrToPtr.
Definition: fx_basic.h:2344
int GetCount() const
Get the number of elements.
Definition: fx_basic.h:2737
~CFX_PrivateData()
The destructor.
~CFX_BinaryBuf()
The destructor.
void * Iterate(FX_BOOL(*callback)(void *param, void *pData), void *param) const
Iterate all units, with a callback function for each unit.
int FX_BOOL
Boolean variable (should be TRUE or FALSE).
Definition: fx_system.h:669
ErrorType
Enumeration for error type.
Definition: fx_basic.h:1296
void RemoveAll()
Remove all (key, value) pair.
Definition: fx_basic.h:2692
virtual void Clear()
Clear the text buffer.
~CFX_TempBuf()
The Destructor.
Definition: fx_basic.h:2316
Definition: fx_basic.h:3944
void SetDestFilter(CFX_DataFilter *pFilter)
Set destination filter. Note the filter will be appended to the end of current filter chain.
Definition: fx_basic.h:4102
void ByteAlign()
Get to byte boundary. If current bit position is not multiplication of 8, the rest of the current byt...
CFX_ArchiveSaver & operator<<(FX_BYTE i)
Left shifts(<<) operator overload. Serialize a single byte.
char const * FX_LPCSTR
Pointer to constant 8-bit Windows (ANSI) characters.
Definition: fx_system.h:683
void AppendChar(FX_DWORD ch)
Append characters to wide text buffer.
Definition: fx_basic.h:3024
FX_INT32 Append(const CFX_ObjectArray &src, FX_INT32 nStart=0, FX_INT32 nCount=-1)
Append an array.
Definition: fx_basic.h:1733
FX_INT32 count
The data count.
Definition: fx_basic.h:3952
T * Get(void)
Get the object pointer.
Definition: fx_basic.h:3920
CFX_WideString FX_DecodeURI(const CFX_ByteString &bsURI)
A simple URI Decode.
CFX_WideString(* m_GetWideString)(CFX_CharMap *pMap, const CFX_ByteString &bstr)
A pointer type to GetWideString function.
Definition: fx_basic.h:973
The data list.
Definition: fx_basic.h:3948
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:2614
FX_BOOL IsExhaustBuffer() const
Indicate whether this filter exhausts the input buffer.
Definition: fx_basic.h:3824
FX_LPBYTE GetAt(FX_INT32 nIndex)
Get the data.
Definition: fx_basic.h:4037
File stream interface, reading & writing.
Definition: fx_stream.h:669
FX_BOOL SetAtGrow(int nIndex, TYPE newElement)
Set an element value at specified position. Potentially growing the array.
Definition: fx_basic.h:1447
Found.
Definition: fx_basic.h:4174
void AppendStr(FX_BSTR str)
Append a non-buffered byte string.
Definition: fx_basic.h:1100
CFX_ObjectStack()
Construct.
Definition: fx_basic.h:1939
FX_INT32 AppendBlock(const void *pBuf, size_t size)
Append a binary buffer block.
void GetResult(CFX_WideStringL &result) const
Get the result.
Definition: fx_basic.h:1060
CFX_ArrayTemplate< FX_INT64 > CFX_FileSizeArray
Type definition for file size array type.
Definition: fx_basic.h:1619
UINT_PTR FX_UINTPTR
Unsigned integral type for pointer precision.
Definition: fx_system.h:728
TYPE * InsertSpaceAt(int nIndex, int nCount)
Insert a number of elements.
Definition: fx_basic.h:1515
void RemoveAt(FX_POSITION pos)
Remove a node at specified position.
FX_BOOL RemoveKey(FX_BSTR key)
Remove existing key.
int RefCount() const
Get the reference count.
Definition: fx_basic.h:3715
FX_BOOL RemoveAt(int nIndex, int nCount=1)
Remove a number of elements at specified position.
Definition: fx_basic.h:1582
Definition: fx_basic.h:3752
void Rewind()
Rewind a bit-stream. Simply set the current bit position to be zero.
Definition: fx_basic.h:3443
FX_DWORD GetHashTableSize() const
Get the internal hash table size. Advanced features for derived classes.
Definition: fx_basic.h:2823
CFX_ObjectArray< CFX_WideString > CFX_WideStringArray
Type definition for a CFX_WideString array type.
Definition: fx_basic.h:1854
void *& operator[](void *key)
Subscript([]) operator overload. Lookup and add if not there.
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...
void operator=(const Ref &ref)
Assignment(=) operator overload. Assign from another reference.
Definition: fx_basic.h:3589
void * GetNext(FX_POSITION &rPosition) const
Get the the current value and set the position to next node.
Definition: fx_basic.h:3069
FX_DWORD nHashValue
Cached hash value, needed for efficient iteration.
Definition: fx_basic.h:2715
void DetachBuffer()
Detach the buffer. Just set buffer pointer to NULL, and set the binary buffer size to zero.
void * GetPrev(FX_POSITION &rPosition) const
Get the the current value and set the position to previous node.
Definition: fx_basic.h:3081
CFX_ArrayTemplate(const CFX_ArrayTemplate &other, IFX_Allocator *pAllocator=0)
The copy constructor.
Definition: fx_basic.h:1321
void * AddSpace()
Add an empty space to the array.
Definition: fx_basic.h:1718
TYPE & Top()
Get the top byte string.
Definition: fx_basic.h:1966
FX_POSITION AddTail(void *newElement)
Add a value to the tail.
void Write(const void *pData, FX_STRSIZE dwSize)
Serialize a memory block.
CFX_SmartPointer(T *pObj)
The constructor.
Definition: fx_basic.h:3910
Definition: fx_basic.h:3504
void ResetStatistics()
Reset statistics.
Definition: fx_basic.h:1288
const TYPE GetAt(int nIndex) const
This method retrieves an element specified by an index number.
Definition: fx_basic.h:1387
ObjectClass & Add()
Add an empty object to the array.
Definition: fx_basic.h:1702
CFX_ArrayTemplate(IFX_Allocator *pAllocator=0)
Constructor, from an allocator.
Definition: fx_basic.h:1312
unsigned char * FX_LPBYTE
Pointer to a FX_BYTE.
Definition: fx_system.h:645
FX_BOOL AppendByte(FX_BYTE byte)
Append a single byte.
Definition: fx_basic.h:128
FX_POSITION Find(void *searchValue, FX_POSITION startAfter=0) const
Find a value starting after specified position.
CFX_ByteString FX_EncodeURI(const CFX_WideString &wsURI)
A simple URI encode.
void Append(FX_INT32 nStart, FX_INT32 nCount)
Append a list data.
Definition: fx_basic.h:4000
void EstimateSize(FX_DWORD size, FX_DWORD grow_by)
Change internal allocation size and grow amount.
CountedObj(const CountedObj &src)
The copy constructor.
Definition: fx_basic.h:3524
FX_BOOL Lookup(FX_DWORD key, FX_DWORD &value) const
Lookup by a key.
FX_BOOL AppendBlock(const void *pBuf, FX_STRSIZE size)
Append a binary buffer block.
const TYPE * GetData() const
Direct Access to the element data (may return NULL).
Definition: fx_basic.h:1430
CFX_ArrayTemplate & operator=(const CFX_ArrayTemplate &src)
Assignment operator overload.
Definition: fx_basic.h:1524
void FreeData()
Free the private data pointed by m_pData.
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:1533
CFX_ArrayTemplate< FX_BYTE > CFX_ByteArray
Type definition for a byte array type.
Definition: fx_basic.h:1611
Foxit allocator interface.
Definition: fx_memory.h:960
void AppendChar(int ch)
Append a single character or byte.
Definition: fx_basic.h:278
void SkipBits(FX_DWORD nBits)
Skip a number of bits.
Definition: fx_basic.h:3436
CFX_SegmentedArray(int segment_units, int index_size=8, IFX_Allocator *pAllocator=0)
Construct with specified segment units.
Definition: fx_basic.h:2194
CNode * pPrev
Pointer to previous node.
Definition: fx_basic.h:3033
void Pop()
Pop the byte string from stack.
Definition: fx_basic.h:2042
Definition: fx_basic.h:947
void RemoveAll()
Remove all key-value pairs in the map.
Invalid array size.
Definition: fx_basic.h:1298
FX_STRSIZE GetLength() const
Get the length of the wide text buffer.
Definition: fx_basic.h:433
void Add(ElementType data)
Add an element.
Definition: fx_basic.h:2206
float FX_FLOAT
32-bit floating-point number.
Definition: fx_system.h:663
FX_BOOL IsEmpty() const
Verify whether the map is empty.
Definition: fx_basic.h:2744
FX_POSITION FindIndex(int index) const
Find a value by index number.
CFX_CountRef(const Ref &ref)
Copy constructor from another reference.
Definition: fx_basic.h:3543
#define FXSYS_assert
Assertion.
Definition: fx_system.h:779
TYPE * AddSpace()
Add an element's space.
Definition: fx_basic.h:1505
CAssoc * pNext
Pointer to next association.
Definition: fx_basic.h:2712
TYPE * GetDataPtr(int index)
Get a pointer to the specified element in the array. Direct pointer access.
Definition: fx_basic.h:1498
FX_INT32 AppendByte(FX_BYTE byte)
Append a single byte.
int GetCount() const
Get the number of elements.
Definition: fx_basic.h:2375
void SetAt(FX_POSITION pos, void *newElement)
Change the value at specified position.
Definition: fx_basic.h:3149
FX_POSITION AddHead(void *newElement)
Add a value to the head.
CFX_ArchiveSaver(IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:485
virtual void Clear()
Clear buffer.
void WriteBits(FX_INT64 value, FX_INT32 nBits)
Write a value of bits.
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:450
FX_BOOL SetAt(int nIndex, TYPE newElement)
This method overwrites an element specified by an index number.
Definition: fx_basic.h:1403
int GetSize() const
Get the size of the array.
Definition: fx_basic.h:1799
CFX_ByteString & Top()
Get the top byte string.
Definition: fx_basic.h:2032
FX_BOOL InsertBlock(FX_STRSIZE pos, const void *pBuf, FX_STRSIZE size)
Insert a binary buffer block at the specified position.
void * GetAt(FX_POSITION rPosition) const
Get an value at specified position.
Definition: fx_basic.h:3111
FX_POSITION GetTailPosition() const
Get the tail position.
Definition: fx_basic.h:3060
FX_BOOL Empty() const
Empty the container.
Definition: fx_basic.h:1871
~CFX_AutoRestorer()
The destructor.
Definition: fx_basic.h:3894
~CFX_BaseSegmentedArray()
The destructor.
CFX_MapPtrTemplate(IFX_Allocator *pAllocator=0)
Default constructor.
Definition: fx_basic.h:2558
Definition: fx_basic.h:1002
FX_STRSIZE GetLength() const
Get the length of the byte text buffer.
Definition: fx_basic.h:330
Definition: fx_basic.h:2550
void AppendString(FX_BSTR str)
Append a non-buffered byte string.
Definition: fx_basic.h:119
FX_BOOL Empty() const
Empty the container.
Definition: fx_basic.h:2012
Definition: fx_basic.h:3249
Definition: fx_basic.h:2298
FX_LPVOID GetNextValue(FX_POSITION &rNextPosition) const
Get the the current value and set the position to next association.
Definition: fx_basic.h:642
void GetNextAssoc(FX_POSITION &rNextPosition, CFX_ByteString &rKey, void *&rValue) const
Get the current association and set the position to next association.
CFX_SortListArray(IFX_Allocator *pAllocator=0)
The constructor.
Definition: fx_basic.h:3967
CFX_BinaryBuf m_Buffer
Definition: fx_basic.h:2696
Failed.
Definition: fx_basic.h:4178
void * key
Key data.
Definition: fx_basic.h:2349
FX_LPWSTR GetBuffer() const
Get a wide character pointer.
Definition: fx_basic.h:440
~CFX_FixedBufGrow()
The Destructor.
Definition: fx_basic.h:2283
Done.
Definition: fx_basic.h:4180
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:1332
CFX_FixedBufGrow(int data_size, IFX_Allocator *pAllocator=0)
Construct with allocator.
Definition: fx_basic.h:2251
CONSTANT BYTE STRING CLASS.
Definition: fx_string.h:51
TYPE * GetData()
Direct Access to the element data (may return NULL).
Definition: fx_basic.h:1437
Definition: fx_basic.h:1636
CFX_ObjectArray< CFX_ByteString > CFX_ByteStringArray
Type definition for a CFX_ByteString array type.
Definition: fx_basic.h:1852
FX_BOOL LookupPrivateData(FX_LPVOID module_id, FX_LPVOID &pData) const
Lookup a private data.
Definition: fx_basic.h:3349
~CFX_SmartPointer()
The destructor.
Definition: fx_basic.h:3913
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:3568
Define a class here derived from user data class, with an additional reference count member.
Definition: fx_basic.h:3513
CFX_ArrayTemplate< FX_FLOAT > CFX_FloatArray
Type definition for float array.
Definition: fx_basic.h:1621
void ClearStatus()
Clear the decoding status.
Definition: fx_basic.h:1044
~CFX_SortListArray()
The destructor.
Definition: fx_basic.h:3970
IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator *pAllocator=0)
Construct with buffer size and special allocator.
FX_DWORD GetHashTableSize() const
Get the internal hash table size. Advanced features for derived classes.
Definition: fx_basic.h:2464
void *& operator[](FX_BSTR key)
Subscript([]) operator overload. Lookup and add if not there.
FX_BOOL NotNull() const
Check if the pointer of the object is not NULL.
Definition: fx_basic.h:3654
TYPE & Top()
Get the top byte data.
Definition: fx_basic.h:1891
FX_BOOL RemoveKey(void *key)
Removing existing (key, ?) pair.
FX_INT32 AppendDWord(FX_DWORD i)
Append a FX_DWORD value.
FX_BOOL Lookup(FX_BSTR key, void *&rValue) const
Lookup by a key.
void SetAt(FX_BSTR key, void *value)
Add a new (key, value) pair. Add if not exist, otherwise modify.
Definition: fx_basic.h:2228
CFX_BitWriter(CFX_BinaryBuf *pBinBuf)
A constructor with bits write.
Definition: fx_basic.h:3465
FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray *pNewArray)
Inset an array at specified position.
Definition: fx_basic.h:1592
~CFX_FileBufferArchive()
The destructor.
void Clear()
Clear data.
Definition: fx_basic.h:4110
void Delete(int start_index, int count)
Delete a inter-zone buffer defining by parameters start_index and count in the binary buffer.
To be continued.
Definition: fx_basic.h:4172
CFX_WideString FX_UrlDecode(const CFX_ByteString &bsUrl)
A simple URL decode.
FX_DWORD GetBits(FX_DWORD nBits)
Get specified number of bits (maximum 32 bits).
ValueType & operator[](KeyType key)
Subscript([]) operator overload. Lookup and add if not there.
Definition: fx_basic.h:2584
BYTE STRING CLASS.
Definition: fx_string.h:317
FX_BOOL Lookup(FX_BSTR key, void *&rValue) const
Lookup by a key.
void SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback)
Set private data.
void operator=(FX_BSTR str)
Assignment(=) operator overload. From a non-buffered byte string.
CFX_CMapByteStringToPtr(IFX_Allocator *pAllocator=0)
The constructor.
virtual ~IFX_BufferArchive()
The destructor.
Definition: fx_basic.h:781
Definition: fx_basic.h:1167
FX_BOOL CopyData(const void *pBuf, FX_STRSIZE size)
Copy from another buffer.
CFX_AutoRestorer(T *location)
The constructor.
Definition: fx_basic.h:3888
unsigned char const * FX_LPCBYTE
Pointer to a constant FX_BYTE.
Definition: fx_system.h:647
FX_LPBYTE GetBuffer() const
Get a byte pointer to the binary buffer.
Definition: fx_basic.h:196
Header file for Memory management related definitions and classes.
void SetDataSize(int data_size)
Construct with allocator.
Definition: fx_basic.h:2269
FX_BOOL Lookup(void *key, void *&rValue) const
Lookup by a key.
FX_ProgressiveStatus
Enumeration for progressive status.
Definition: fx_basic.h:4168
void Pop()
Pop the data from stack.
Definition: fx_basic.h:1901
wchar_t * FX_LPWSTR
Pointer to Unicode characters.
Definition: fx_system.h:710
FX_BOOL NeedNewSrc()
Indicate whether this filter needs to input new src data.
FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount=1)
Inset one or more continuous element at specified position.
Definition: fx_basic.h:1566
Index out of range.
Definition: fx_basic.h:1304
IFX_Allocator * m_pAllocator
Special allocator pointer. NULL means to use default allocator.
Definition: fx_basic.h:2160
FX_BOOL IsEOF() const
Detect EOF.
Definition: fx_basic.h:3789
void Push(const TYPE &val)
Push the byte string to stack.
Definition: fx_basic.h:1988
~CFX_CMapByteStringToPtr()
The destructor.
void TakeOver(CFX_BinaryBuf &other)
Takeover another buffer.
#define NULL
The null-pointer value.
Definition: fx_system.h:767
void * GetValueAt(void *key) const
Get a value pointer by a key.
FX_INT32 AppendInt64(FX_INT64 i)
Append a FX_INT64 value.
CFX_ArchiveLoader & operator >>(FX_BYTE &i)
Right shifts(>>) operator overload. De-serialize a byte.
int GetUpperBound() const
Get the upper bound in the array, actually the maximum valid index.
Definition: fx_basic.h:1358
int Size() const
Get size of the container.
Definition: fx_basic.h:1956
void RemoveKey(FX_BSTR key)
Removing existing (key, ?) pair.
Definition: fx_basic.h:2629
Definition: fx_basic.h:2338
Definition: fx_basic.h:3457
FX_BOOL IsEOF() const
Check if reached end of the stream.
Definition: fx_basic.h:3427
CFX_ByteString FX_UrlEncode(const CFX_WideString &wsUrl)
A simple URL encode.
void Push(const TYPE &val)
Push the data to stack.
Definition: fx_basic.h:1913
#define FX_FILESIZE
Support large file directly.
Definition: fx_stream.h:138
FX_POSITION GetStartPosition() const
Get the first key-value pair position. iterating all (key, value) pairs.
Definition: fx_basic.h:2443
Definition: fx_basic.h:2703
void Clear()
Clear the data list.
Definition: fx_basic.h:3980
CountedObj()
The constructor.
Definition: fx_basic.h:3517
void RemoveAll()
Remove all objects in the array.
Definition: fx_basic.h:1843
int GetCount() const
Get the number of nodes.
Definition: fx_basic.h:3121
FX_BOOL AbortAll()
Indicate whether to abort the filter process, including all dest filter.
ObjClass * GetModify()
Get a modifiable copy of the object.
Definition: fx_basic.h:3667
void GetNextAssoc(FX_POSITION &pos, FX_DWORD &key, FX_DWORD &value) const
Get the next association.
void RemoveAll()
Remove all the (key, value) pairs in the map.
int Size() const
Get size of the container.
Definition: fx_basic.h:1881
#define FX_Allocator_Free(fxAllocator, ptr)
Free memory block on an allocator.
Definition: fx_memory.h:1057
FX_POSITION GetPrevPosition(FX_POSITION pos) const
Get the previous position.
Definition: fx_basic.h:3102
CFX_WideStringC GetWideString() const
Get a wide string from the wide text buffer.
~CFX_MapPtrToPtr()
The Destructor.
CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize)
Construct a loading archive.
PD_CALLBACK_FREEDATA m_pCallback
Pointer of a callback function provided by custom module for deallocating private data.
Definition: fx_basic.h:3265
FX_STRSIZE GetSize() const
Get the length of the binary buffer.
Definition: fx_basic.h:203
CFX_ByteString(* m_GetByteString)(CFX_CharMap *pMap, const CFX_WideString &wstr)
A pointer type to GetByteString function.
Definition: fx_basic.h:986
Definition: fx_basic.h:3393
void SetNull()
Set the pointer of the object to be null.
Definition: fx_basic.h:3689
Definition: fx_basic.h:3881
CFX_ArrayTemplate< FX_WCHAR > CFX_WCHARArray
Type definition for FX_WHAR array.
Definition: fx_basic.h:1625
FX_INT32 AppendString(FX_BSTR lpsz)
Append a byte string value.
void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow=true)
Initialize the hash table.
FX_BOOL operator==(const Ref &ref) const
Comparison(==) operator overload. Compare with another reference.
Definition: fx_basic.h:3705
ObjectClass * GetDataPtr(int index) const
Get a pointer to the specified element in the array. Direct pointer access.
Definition: fx_basic.h:1822
void * value
Value data.
Definition: fx_basic.h:2719
INT_PTR FX_INTPTR
Signed integral type for pointer precision.
Definition: fx_system.h:726
Header file for exception class.
unsigned char FX_BYTE
Byte (8 bits).
Definition: fx_system.h:643
void * GetAt(int index) const
Get a typeless pointer to an element data.
void RemoveAll()
Remove all elements in the array.
void Pop()
Pop the byte string from stack.
Definition: fx_basic.h:1976
Definition: fx_basic.h:868
void Decref()
Decrease the reference.
Definition: fx_basic.h:3736
virtual ~IFX_Pause()
Destructor.
Definition: fx_basic.h:3756
CFX_ArrayTemplate< void * > CFX_PtrArray
Type definition for: a typeless pointer array type.
Definition: fx_basic.h:1617
Definition: fx_basic.h:476
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.
int Find(const TYPE &data, int iStart=0) const
Find an element from specified position to last.
Definition: fx_basic.h:1601
void Input(FX_BYTE byte)
Input a byte.
Header file for system related definitions.
FX_LPVOID GetNextValue(FX_POSITION &rNextPosition) const
Get the the current value and set the position to next association.
CFX_ByteStringC GetByteString() const
Get a byte string from the buffer.
void Add(FX_INT32 nStart, FX_INT32 nCount)
Add a list data.
Definition: fx_basic.h:4123
CAssoc * pNext
Pointer to next association.
Definition: fx_basic.h:2347