Remove more dead code from fx_basic.h
[pdfium.git] / core / include / fxcrt / fx_basic.h
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #ifndef CORE_INCLUDE_FXCRT_FX_BASIC_H_
8 #define CORE_INCLUDE_FXCRT_FX_BASIC_H_
9
10 #include "fx_memory.h"
11 #include "fx_stream.h"
12 #include "fx_string.h"
13 #include "fx_system.h"
14
15 // The FX_ArraySize(arr) macro returns the # of elements in an array arr.
16 // The expression is a compile-time constant, and therefore can be
17 // used in defining new arrays, for example.  If you use FX_ArraySize on
18 // a pointer by mistake, you will get a compile-time error.
19 //
20 // One caveat is that FX_ArraySize() doesn't accept any array of an
21 // anonymous type or a type defined inside a function.
22 #define FX_ArraySize(array) (sizeof(ArraySizeHelper(array)))
23
24 // This template function declaration is used in defining FX_ArraySize.
25 // Note that the function doesn't need an implementation, as we only
26 // use its type.
27 template <typename T, size_t N>
28 char(&ArraySizeHelper(T(&array)[N]))[N];
29
30 class CFX_BinaryBuf {
31  public:
32   CFX_BinaryBuf();
33   CFX_BinaryBuf(FX_STRSIZE size);
34
35   ~CFX_BinaryBuf();
36
37   void Clear();
38
39   void EstimateSize(FX_STRSIZE size, FX_STRSIZE alloc_step = 0);
40
41   void AppendBlock(const void* pBuf, FX_STRSIZE size);
42
43   void AppendFill(uint8_t byte, FX_STRSIZE count);
44
45   void AppendString(const CFX_ByteStringC& str) {
46     AppendBlock(str.GetPtr(), str.GetLength());
47   }
48
49   inline void AppendByte(uint8_t byte) {
50     if (m_AllocSize <= m_DataSize) {
51       ExpandBuf(1);
52     }
53     m_pBuffer[m_DataSize++] = byte;
54   }
55
56   void InsertBlock(FX_STRSIZE pos, const void* pBuf, FX_STRSIZE size);
57
58   void AttachData(void* pBuf, FX_STRSIZE size);
59
60   void CopyData(const void* pBuf, FX_STRSIZE size);
61
62   void TakeOver(CFX_BinaryBuf& other);
63
64   void Delete(int start_index, int count);
65
66   uint8_t* GetBuffer() const { return m_pBuffer; }
67
68   FX_STRSIZE GetSize() const { return m_DataSize; }
69
70   CFX_ByteStringC GetByteString() const;
71
72   void DetachBuffer();
73
74  protected:
75   FX_STRSIZE m_AllocStep;
76
77   uint8_t* m_pBuffer;
78
79   FX_STRSIZE m_DataSize;
80
81   FX_STRSIZE m_AllocSize;
82
83   void ExpandBuf(FX_STRSIZE size);
84 };
85 class CFX_ByteTextBuf : public CFX_BinaryBuf {
86  public:
87   void operator=(const CFX_ByteStringC& str);
88
89   void AppendChar(int ch) { AppendByte((uint8_t)ch); }
90
91   CFX_ByteTextBuf& operator<<(int i);
92
93   CFX_ByteTextBuf& operator<<(FX_DWORD i);
94
95   CFX_ByteTextBuf& operator<<(double f);
96
97   CFX_ByteTextBuf& operator<<(const CFX_ByteStringC& lpsz);
98
99   CFX_ByteTextBuf& operator<<(const CFX_ByteTextBuf& buf);
100
101   FX_STRSIZE GetLength() const { return m_DataSize; }
102 };
103 class CFX_WideTextBuf : public CFX_BinaryBuf {
104  public:
105   void operator=(const FX_WCHAR* lpsz);
106
107   void operator=(const CFX_WideStringC& str);
108
109   void AppendChar(FX_WCHAR wch);
110
111   CFX_WideTextBuf& operator<<(int i);
112
113   CFX_WideTextBuf& operator<<(double f);
114
115   CFX_WideTextBuf& operator<<(const FX_WCHAR* lpsz);
116
117   CFX_WideTextBuf& operator<<(const CFX_WideStringC& str);
118   CFX_WideTextBuf& operator<<(const CFX_WideString& str);
119
120   CFX_WideTextBuf& operator<<(const CFX_WideTextBuf& buf);
121
122   FX_STRSIZE GetLength() const { return m_DataSize / sizeof(FX_WCHAR); }
123
124   FX_WCHAR* GetBuffer() const { return (FX_WCHAR*)m_pBuffer; }
125
126   void Delete(int start_index, int count) {
127     CFX_BinaryBuf::Delete(start_index * sizeof(FX_WCHAR),
128                           count * sizeof(FX_WCHAR));
129   }
130
131   CFX_WideStringC GetWideString() const;
132 };
133
134 class IFX_BufferArchive {
135  public:
136   IFX_BufferArchive(FX_STRSIZE size);
137   virtual ~IFX_BufferArchive() {}
138
139   virtual void Clear();
140
141   FX_BOOL Flush();
142
143   int32_t AppendBlock(const void* pBuf, size_t size);
144
145   int32_t AppendByte(uint8_t byte);
146
147   int32_t AppendDWord(FX_DWORD i);
148
149   int32_t AppendString(const CFX_ByteStringC& lpsz);
150
151  protected:
152   virtual FX_BOOL DoWork(const void* pBuf, size_t size) = 0;
153
154   FX_STRSIZE m_BufSize;
155
156   uint8_t* m_pBuffer;
157
158   FX_STRSIZE m_Length;
159 };
160
161 class CFX_FileBufferArchive : public IFX_BufferArchive {
162  public:
163   CFX_FileBufferArchive(FX_STRSIZE size = 32768);
164   ~CFX_FileBufferArchive() override;
165
166   void Clear() override;
167   FX_BOOL AttachFile(IFX_StreamWrite* pFile, FX_BOOL bTakeover = FALSE);
168
169  private:
170   FX_BOOL DoWork(const void* pBuf, size_t size) override;
171
172   IFX_StreamWrite* m_pFile;
173   FX_BOOL m_bTakeover;
174 };
175
176 struct CFX_CharMap {
177   static CFX_CharMap* GetDefaultMapper(int32_t codepage = 0);
178
179   CFX_WideString (*m_GetWideString)(CFX_CharMap* pMap,
180                                     const CFX_ByteString& bstr);
181
182   CFX_ByteString (*m_GetByteString)(CFX_CharMap* pMap,
183                                     const CFX_WideString& wstr);
184
185   int32_t (*m_GetCodePage)();
186 };
187 class CFX_UTF8Decoder {
188  public:
189   CFX_UTF8Decoder() { m_PendingBytes = 0; }
190
191   void Clear();
192
193   void Input(uint8_t byte);
194
195   void AppendChar(FX_DWORD ch);
196
197   void ClearStatus() { m_PendingBytes = 0; }
198
199   CFX_WideStringC GetResult() const { return m_Buffer.GetWideString(); }
200
201  protected:
202   int m_PendingBytes;
203
204   FX_DWORD m_PendingChar;
205
206   CFX_WideTextBuf m_Buffer;
207 };
208
209 class CFX_UTF8Encoder {
210  public:
211   CFX_UTF8Encoder() {}
212
213   void Input(FX_WCHAR unicode);
214   void AppendStr(const CFX_ByteStringC& str) { m_Buffer << str; }
215   CFX_ByteStringC GetResult() const { return m_Buffer.GetByteString(); }
216
217  protected:
218   CFX_ByteTextBuf m_Buffer;
219 };
220
221 class CFX_BasicArray {
222  protected:
223   CFX_BasicArray(int unit_size);
224
225   ~CFX_BasicArray();
226
227   FX_BOOL SetSize(int nNewSize);
228
229   FX_BOOL Append(const CFX_BasicArray& src);
230
231   FX_BOOL Copy(const CFX_BasicArray& src);
232
233   uint8_t* InsertSpaceAt(int nIndex, int nCount);
234
235   FX_BOOL RemoveAt(int nIndex, int nCount);
236
237   FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
238
239   const void* GetDataPtr(int index) const;
240
241  protected:
242   uint8_t* m_pData;
243
244   int m_nSize;
245
246   int m_nMaxSize;
247
248   int m_nUnitSize;
249 };
250 template <class TYPE>
251 class CFX_ArrayTemplate : public CFX_BasicArray {
252  public:
253   CFX_ArrayTemplate() : CFX_BasicArray(sizeof(TYPE)) {}
254
255   int GetSize() const { return m_nSize; }
256
257   int GetUpperBound() const { return m_nSize - 1; }
258
259   FX_BOOL SetSize(int nNewSize) { return CFX_BasicArray::SetSize(nNewSize); }
260
261   void RemoveAll() { SetSize(0); }
262
263   const TYPE GetAt(int nIndex) const {
264     if (nIndex < 0 || nIndex >= m_nSize) {
265       return (const TYPE&)(*(volatile const TYPE*)NULL);
266     }
267     return ((const TYPE*)m_pData)[nIndex];
268   }
269
270   FX_BOOL SetAt(int nIndex, TYPE newElement) {
271     if (nIndex < 0 || nIndex >= m_nSize) {
272       return FALSE;
273     }
274     ((TYPE*)m_pData)[nIndex] = newElement;
275     return TRUE;
276   }
277
278   TYPE& ElementAt(int nIndex) {
279     if (nIndex < 0 || nIndex >= m_nSize) {
280       return *(TYPE*)NULL;
281     }
282     return ((TYPE*)m_pData)[nIndex];
283   }
284
285   const TYPE* GetData() const { return (const TYPE*)m_pData; }
286
287   TYPE* GetData() { return (TYPE*)m_pData; }
288
289   FX_BOOL SetAtGrow(int nIndex, TYPE newElement) {
290     if (nIndex < 0) {
291       return FALSE;
292     }
293     if (nIndex >= m_nSize)
294       if (!SetSize(nIndex + 1)) {
295         return FALSE;
296       }
297     ((TYPE*)m_pData)[nIndex] = newElement;
298     return TRUE;
299   }
300
301   FX_BOOL Add(TYPE newElement) {
302     if (m_nSize < m_nMaxSize) {
303       m_nSize++;
304     } else if (!SetSize(m_nSize + 1)) {
305       return FALSE;
306     }
307     ((TYPE*)m_pData)[m_nSize - 1] = newElement;
308     return TRUE;
309   }
310
311   FX_BOOL Append(const CFX_ArrayTemplate& src) {
312     return CFX_BasicArray::Append(src);
313   }
314
315   FX_BOOL Copy(const CFX_ArrayTemplate& src) {
316     return CFX_BasicArray::Copy(src);
317   }
318
319   TYPE* GetDataPtr(int index) {
320     return (TYPE*)CFX_BasicArray::GetDataPtr(index);
321   }
322
323   TYPE* AddSpace() { return (TYPE*)CFX_BasicArray::InsertSpaceAt(m_nSize, 1); }
324
325   TYPE* InsertSpaceAt(int nIndex, int nCount) {
326     return (TYPE*)CFX_BasicArray::InsertSpaceAt(nIndex, nCount);
327   }
328
329   const TYPE operator[](int nIndex) const {
330     if (nIndex < 0 || nIndex >= m_nSize) {
331       *(volatile char*)0 = '\0';
332     }
333     return ((const TYPE*)m_pData)[nIndex];
334   }
335
336   TYPE& operator[](int nIndex) {
337     if (nIndex < 0 || nIndex >= m_nSize) {
338       *(volatile char*)0 = '\0';
339     }
340     return ((TYPE*)m_pData)[nIndex];
341   }
342
343   FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount = 1) {
344     if (!InsertSpaceAt(nIndex, nCount)) {
345       return FALSE;
346     }
347     while (nCount--) {
348       ((TYPE*)m_pData)[nIndex++] = newElement;
349     }
350     return TRUE;
351   }
352
353   FX_BOOL RemoveAt(int nIndex, int nCount = 1) {
354     return CFX_BasicArray::RemoveAt(nIndex, nCount);
355   }
356
357   FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray) {
358     return CFX_BasicArray::InsertAt(nStartIndex, pNewArray);
359   }
360
361   int Find(TYPE data, int iStart = 0) const {
362     if (iStart < 0) {
363       return -1;
364     }
365     for (; iStart < (int)m_nSize; iStart++)
366       if (((TYPE*)m_pData)[iStart] == data) {
367         return iStart;
368       }
369     return -1;
370   }
371 };
372 typedef CFX_ArrayTemplate<uint8_t> CFX_ByteArray;
373 typedef CFX_ArrayTemplate<FX_WORD> CFX_WordArray;
374 typedef CFX_ArrayTemplate<FX_DWORD> CFX_DWordArray;
375 typedef CFX_ArrayTemplate<void*> CFX_PtrArray;
376 typedef CFX_ArrayTemplate<FX_FILESIZE> CFX_FileSizeArray;
377
378 template <class ObjectClass>
379 class CFX_ObjectArray : public CFX_BasicArray {
380  public:
381   CFX_ObjectArray() : CFX_BasicArray(sizeof(ObjectClass)) {}
382
383   ~CFX_ObjectArray() { RemoveAll(); }
384
385   void Add(const ObjectClass& data) {
386     new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
387   }
388
389   ObjectClass& Add() {
390     return *(ObjectClass*)new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
391   }
392
393   void* AddSpace() { return InsertSpaceAt(m_nSize, 1); }
394
395   int32_t Append(const CFX_ObjectArray& src,
396                  int32_t nStart = 0,
397                  int32_t nCount = -1) {
398     if (nCount == 0) {
399       return 0;
400     }
401     int32_t nSize = src.GetSize();
402     if (!nSize) {
403       return 0;
404     }
405     FXSYS_assert(nStart > -1 && nStart < nSize);
406     if (nCount < 0) {
407       nCount = nSize;
408     }
409     if (nStart + nCount > nSize) {
410       nCount = nSize - nStart;
411     }
412     if (nCount < 1) {
413       return 0;
414     }
415     nSize = m_nSize;
416     InsertSpaceAt(m_nSize, nCount);
417     ObjectClass* pStartObj = (ObjectClass*)GetDataPtr(nSize);
418     nSize = nStart + nCount;
419     for (int32_t i = nStart; i < nSize; i++, pStartObj++) {
420       new ((void*)pStartObj) ObjectClass(src[i]);
421     }
422     return nCount;
423   }
424
425   int32_t Copy(const CFX_ObjectArray& src,
426                int32_t nStart = 0,
427                int32_t nCount = -1) {
428     if (nCount == 0) {
429       return 0;
430     }
431     int32_t nSize = src.GetSize();
432     if (!nSize) {
433       return 0;
434     }
435     FXSYS_assert(nStart > -1 && nStart < nSize);
436     if (nCount < 0) {
437       nCount = nSize;
438     }
439     if (nStart + nCount > nSize) {
440       nCount = nSize - nStart;
441     }
442     if (nCount < 1) {
443       return 0;
444     }
445     RemoveAll();
446     SetSize(nCount);
447     ObjectClass* pStartObj = (ObjectClass*)m_pData;
448     nSize = nStart + nCount;
449     for (int32_t i = nStart; i < nSize; i++, pStartObj++) {
450       new ((void*)pStartObj) ObjectClass(src[i]);
451     }
452     return nCount;
453   }
454
455   int GetSize() const { return m_nSize; }
456
457   ObjectClass& operator[](int index) const {
458     FXSYS_assert(index < m_nSize);
459     return *(ObjectClass*)CFX_BasicArray::GetDataPtr(index);
460   }
461
462   ObjectClass* GetDataPtr(int index) {
463     return (ObjectClass*)CFX_BasicArray::GetDataPtr(index);
464   }
465
466   void RemoveAt(int index) {
467     FXSYS_assert(index < m_nSize);
468     ((ObjectClass*)GetDataPtr(index))->~ObjectClass();
469     CFX_BasicArray::RemoveAt(index, 1);
470   }
471
472   void RemoveAll() {
473     for (int i = 0; i < m_nSize; i++) {
474       ((ObjectClass*)GetDataPtr(i))->~ObjectClass();
475     }
476     CFX_BasicArray::SetSize(0);
477   }
478 };
479 typedef CFX_ObjectArray<CFX_ByteString> CFX_ByteStringArray;
480 typedef CFX_ObjectArray<CFX_WideString> CFX_WideStringArray;
481 class CFX_BaseSegmentedArray {
482  public:
483   CFX_BaseSegmentedArray(int unit_size = 1,
484                          int segment_units = 512,
485                          int index_size = 8);
486
487   ~CFX_BaseSegmentedArray();
488
489   void SetUnitSize(int unit_size, int segment_units, int index_size = 8);
490
491   void* Add();
492
493   void* GetAt(int index) const;
494
495   void RemoveAll();
496
497   void Delete(int index, int count = 1);
498
499   int GetSize() const { return m_DataSize; }
500
501   int GetSegmentSize() const { return m_SegmentSize; }
502
503   int GetUnitSize() const { return m_UnitSize; }
504
505   void* Iterate(FX_BOOL (*callback)(void* param, void* pData),
506                 void* param) const;
507
508  private:
509   int m_UnitSize;
510
511   short m_SegmentSize;
512
513   uint8_t m_IndexSize;
514
515   uint8_t m_IndexDepth;
516
517   int m_DataSize;
518
519   void* m_pIndex;
520   void** GetIndex(int seg_index) const;
521   void* IterateIndex(int level,
522                      int& start,
523                      void** pIndex,
524                      FX_BOOL (*callback)(void* param, void* pData),
525                      void* param) const;
526   void* IterateSegment(const uint8_t* pSegment,
527                        int count,
528                        FX_BOOL (*callback)(void* param, void* pData),
529                        void* param) const;
530 };
531 template <class ElementType>
532 class CFX_SegmentedArray : public CFX_BaseSegmentedArray {
533  public:
534   CFX_SegmentedArray(int segment_units, int index_size = 8)
535       : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size) {
536   }
537
538   void Add(ElementType data) {
539     *(ElementType*)CFX_BaseSegmentedArray::Add() = data;
540   }
541
542   ElementType& operator[](int index) {
543     return *(ElementType*)CFX_BaseSegmentedArray::GetAt(index);
544   }
545 };
546 template <class DataType, int FixedSize>
547 class CFX_FixedBufGrow {
548  public:
549   CFX_FixedBufGrow() : m_pData(NULL) {}
550   CFX_FixedBufGrow(int data_size) : m_pData(NULL) {
551     if (data_size > FixedSize) {
552       m_pData = FX_Alloc(DataType, data_size);
553     } else {
554       FXSYS_memset(m_Data, 0, sizeof(DataType) * FixedSize);
555     }
556   }
557   void SetDataSize(int data_size) {
558     FX_Free(m_pData);
559     m_pData = NULL;
560     if (data_size > FixedSize) {
561       m_pData = FX_Alloc(DataType, data_size);
562     } else {
563       FXSYS_memset(m_Data, 0, sizeof(DataType) * FixedSize);
564     }
565   }
566   ~CFX_FixedBufGrow() { FX_Free(m_pData); }
567   operator DataType*() { return m_pData ? m_pData : m_Data; }
568
569  private:
570   DataType m_Data[FixedSize];
571   DataType* m_pData;
572 };
573 class CFX_MapPtrToPtr {
574  protected:
575   struct CAssoc {
576     CAssoc* pNext;
577
578     void* key;
579
580     void* value;
581   };
582
583  public:
584   CFX_MapPtrToPtr(int nBlockSize = 10);
585
586   ~CFX_MapPtrToPtr();
587
588   int GetCount() const { return m_nCount; }
589
590   FX_BOOL IsEmpty() const { return m_nCount == 0; }
591
592   FX_BOOL Lookup(void* key, void*& rValue) const;
593
594   void* GetValueAt(void* key) const;
595
596   void*& operator[](void* key);
597
598   void SetAt(void* key, void* newValue) { (*this)[key] = newValue; }
599
600   FX_BOOL RemoveKey(void* key);
601
602   void RemoveAll();
603
604   FX_POSITION GetStartPosition() const {
605     return (m_nCount == 0) ? NULL : (FX_POSITION)-1;
606   }
607
608   void GetNextAssoc(FX_POSITION& rNextPosition,
609                     void*& rKey,
610                     void*& rValue) const;
611
612   FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
613
614   void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
615
616  protected:
617   CAssoc** m_pHashTable;
618
619   FX_DWORD m_nHashTableSize;
620
621   int m_nCount;
622
623   CAssoc* m_pFreeList;
624
625   struct CFX_Plex* m_pBlocks;
626
627   int m_nBlockSize;
628
629   FX_DWORD HashKey(void* key) const;
630
631   CAssoc* NewAssoc();
632
633   void FreeAssoc(CAssoc* pAssoc);
634
635   CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
636 };
637
638 class CFX_CMapDWordToDWord {
639  public:
640   FX_BOOL Lookup(FX_DWORD key, FX_DWORD& value) const;
641
642   void SetAt(FX_DWORD key, FX_DWORD value);
643
644   void EstimateSize(FX_DWORD size, FX_DWORD grow_by);
645
646   FX_POSITION GetStartPosition() const;
647
648   void GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;
649
650  protected:
651   CFX_BinaryBuf m_Buffer;
652 };
653 class CFX_CMapByteStringToPtr {
654  public:
655   CFX_CMapByteStringToPtr();
656
657   ~CFX_CMapByteStringToPtr();
658
659   void RemoveAll();
660
661   FX_POSITION GetStartPosition() const;
662
663   void GetNextAssoc(FX_POSITION& rNextPosition,
664                     CFX_ByteString& rKey,
665                     void*& rValue) const;
666
667   void* GetNextValue(FX_POSITION& rNextPosition) const;
668
669   FX_BOOL Lookup(const CFX_ByteStringC& key, void*& rValue) const;
670
671   void SetAt(const CFX_ByteStringC& key, void* value);
672
673   void RemoveKey(const CFX_ByteStringC& key);
674
675   int GetCount() const;
676
677   void AddValue(const CFX_ByteStringC& key, void* pValue);
678
679  private:
680   CFX_BaseSegmentedArray m_Buffer;
681 };
682 class CFX_PtrList {
683  protected:
684   struct CNode {
685     CNode* pNext;
686
687     CNode* pPrev;
688
689     void* data;
690   };
691
692  public:
693   CFX_PtrList(int nBlockSize = 10);
694
695   FX_POSITION GetHeadPosition() const { return (FX_POSITION)m_pNodeHead; }
696
697   FX_POSITION GetTailPosition() const { return (FX_POSITION)m_pNodeTail; }
698
699   void* GetNext(FX_POSITION& rPosition) const {
700     CNode* pNode = (CNode*)rPosition;
701     rPosition = (FX_POSITION)pNode->pNext;
702     return pNode->data;
703   }
704
705   void* GetPrev(FX_POSITION& rPosition) const {
706     CNode* pNode = (CNode*)rPosition;
707     rPosition = (FX_POSITION)pNode->pPrev;
708     return pNode->data;
709   }
710
711   FX_POSITION GetNextPosition(FX_POSITION pos) const {
712     return ((CNode*)pos)->pNext;
713   }
714
715   FX_POSITION GetPrevPosition(FX_POSITION pos) const {
716     return ((CNode*)pos)->pPrev;
717   }
718
719   void* GetAt(FX_POSITION rPosition) const {
720     CNode* pNode = (CNode*)rPosition;
721     return pNode->data;
722   }
723
724   int GetCount() const { return m_nCount; }
725
726   FX_POSITION AddTail(void* newElement);
727
728   FX_POSITION AddHead(void* newElement);
729
730   void SetAt(FX_POSITION pos, void* newElement) {
731     CNode* pNode = (CNode*)pos;
732     pNode->data = newElement;
733   }
734
735   FX_POSITION InsertAfter(FX_POSITION pos, void* newElement);
736
737   FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL) const;
738
739   FX_POSITION FindIndex(int index) const;
740
741   void RemoveAt(FX_POSITION pos);
742
743   void RemoveAll();
744
745  protected:
746   CNode* m_pNodeHead;
747
748   CNode* m_pNodeTail;
749
750   int m_nCount;
751
752   CNode* m_pNodeFree;
753
754   struct CFX_Plex* m_pBlocks;
755
756   int m_nBlockSize;
757
758   CNode* NewNode(CNode* pPrev, CNode* pNext);
759
760   void FreeNode(CNode* pNode);
761
762  public:
763   ~CFX_PtrList();
764 };
765 typedef void (*PD_CALLBACK_FREEDATA)(void* pData);
766 struct FX_PRIVATEDATA {
767   void FreeData();
768
769   void* m_pModuleId;
770
771   void* m_pData;
772
773   PD_CALLBACK_FREEDATA m_pCallback;
774
775   FX_BOOL m_bSelfDestruct;
776 };
777 class CFX_PrivateData {
778  public:
779   ~CFX_PrivateData();
780
781   void ClearAll();
782
783   void SetPrivateData(void* module_id,
784                       void* pData,
785                       PD_CALLBACK_FREEDATA callback);
786
787   void SetPrivateObj(void* module_id, CFX_DestructObject* pObj);
788
789   void* GetPrivateData(void* module_id);
790
791   FX_BOOL LookupPrivateData(void* module_id, void*& pData) const {
792     if (!module_id) {
793       return FALSE;
794     }
795     FX_DWORD nCount = m_DataList.GetSize();
796     for (FX_DWORD n = 0; n < nCount; n++) {
797       if (m_DataList[n].m_pModuleId == module_id) {
798         pData = m_DataList[n].m_pData;
799         return TRUE;
800       }
801     }
802     return FALSE;
803   }
804
805   FX_BOOL RemovePrivateData(void* module_id);
806
807  protected:
808   CFX_ArrayTemplate<FX_PRIVATEDATA> m_DataList;
809
810   void AddData(void* module_id,
811                void* pData,
812                PD_CALLBACK_FREEDATA callback,
813                FX_BOOL bSelfDestruct);
814 };
815 class CFX_BitStream {
816  public:
817   void Init(const uint8_t* pData, FX_DWORD dwSize);
818
819   FX_DWORD GetBits(FX_DWORD nBits);
820
821   void ByteAlign();
822
823   FX_BOOL IsEOF() { return m_BitPos >= m_BitSize; }
824
825   void SkipBits(FX_DWORD nBits) { m_BitPos += nBits; }
826
827   void Rewind() { m_BitPos = 0; }
828
829  protected:
830   FX_DWORD m_BitPos;
831
832   FX_DWORD m_BitSize;
833
834   const uint8_t* m_pData;
835 };
836 template <class ObjClass>
837 class CFX_CountRef {
838  public:
839   typedef CFX_CountRef<ObjClass> Ref;
840
841   class CountedObj : public ObjClass {
842    public:
843     CountedObj() {}
844
845     CountedObj(const CountedObj& src) : ObjClass(src) {}
846
847     int m_RefCount;
848   };
849
850   CFX_CountRef() { m_pObject = NULL; }
851
852   CFX_CountRef(const Ref& ref) {
853     m_pObject = ref.m_pObject;
854     if (m_pObject) {
855       m_pObject->m_RefCount++;
856     }
857   }
858
859   ~CFX_CountRef() {
860     if (!m_pObject) {
861       return;
862     }
863     m_pObject->m_RefCount--;
864     if (m_pObject->m_RefCount <= 0) {
865       delete m_pObject;
866     }
867   }
868
869   ObjClass* New() {
870     if (m_pObject) {
871       m_pObject->m_RefCount--;
872       if (m_pObject->m_RefCount <= 0) {
873         delete m_pObject;
874       }
875     }
876     m_pObject = new CountedObj;
877     m_pObject->m_RefCount = 1;
878     return m_pObject;
879   }
880
881   void operator=(const Ref& ref) {
882     if (ref.m_pObject) {
883       ref.m_pObject->m_RefCount++;
884     }
885     if (m_pObject) {
886       m_pObject->m_RefCount--;
887       if (m_pObject->m_RefCount <= 0) {
888         delete m_pObject;
889       }
890     }
891     m_pObject = ref.m_pObject;
892   }
893
894   void operator=(void* p) {
895     FXSYS_assert(p == 0);
896     if (m_pObject == NULL) {
897       return;
898     }
899     m_pObject->m_RefCount--;
900     if (m_pObject->m_RefCount <= 0) {
901       delete m_pObject;
902     }
903     m_pObject = NULL;
904   }
905
906   const ObjClass* GetObject() const { return m_pObject; }
907
908   operator const ObjClass*() const { return m_pObject; }
909
910   FX_BOOL IsNull() const { return m_pObject == NULL; }
911
912   FX_BOOL NotNull() const { return m_pObject != NULL; }
913
914   ObjClass* GetModify() {
915     if (m_pObject == NULL) {
916       m_pObject = new CountedObj;
917       m_pObject->m_RefCount = 1;
918     } else if (m_pObject->m_RefCount > 1) {
919       m_pObject->m_RefCount--;
920       CountedObj* pOldObject = m_pObject;
921       m_pObject = new CountedObj(*pOldObject);
922       m_pObject->m_RefCount = 1;
923     }
924     return m_pObject;
925   }
926
927   void SetNull() {
928     if (m_pObject == NULL) {
929       return;
930     }
931     m_pObject->m_RefCount--;
932     if (m_pObject->m_RefCount <= 0) {
933       delete m_pObject;
934     }
935     m_pObject = NULL;
936   }
937
938   FX_BOOL operator==(const Ref& ref) const {
939     return m_pObject == ref.m_pObject;
940   }
941
942  protected:
943   CountedObj* m_pObject;
944 };
945 class IFX_Pause {
946  public:
947   virtual ~IFX_Pause() {}
948   virtual FX_BOOL NeedToPauseNow() = 0;
949 };
950
951 template <typename T>
952 class CFX_AutoRestorer {
953  public:
954   explicit CFX_AutoRestorer(T* location) {
955     m_Location = location;
956     m_OldValue = *location;
957   }
958   ~CFX_AutoRestorer() { *m_Location = m_OldValue; }
959
960  private:
961   T* m_Location;
962   T m_OldValue;
963 };
964
965 template <class T>
966 class CFX_SmartPointer {
967  public:
968   CFX_SmartPointer(T* pObj) : m_pObj(pObj) {}
969   ~CFX_SmartPointer() { m_pObj->Release(); }
970   T* Get(void) { return m_pObj; }
971   T& operator*(void) { return *m_pObj; }
972   T* operator->(void) { return m_pObj; }
973
974  protected:
975   T* m_pObj;
976 };
977 #define FX_DATALIST_LENGTH 1024
978 template <size_t unit>
979 class CFX_SortListArray {
980  protected:
981   struct DataList {
982     int32_t start;
983
984     int32_t count;
985     uint8_t* data;
986   };
987
988  public:
989   CFX_SortListArray() : m_CurList(0) {}
990
991   ~CFX_SortListArray() { Clear(); }
992
993   void Clear() {
994     for (int32_t i = m_DataLists.GetUpperBound(); i >= 0; i--) {
995       DataList list = m_DataLists.ElementAt(i);
996       FX_Free(list.data);
997     }
998     m_DataLists.RemoveAll();
999     m_CurList = 0;
1000   }
1001
1002   void Append(int32_t nStart, int32_t nCount) {
1003     if (nStart < 0) {
1004       return;
1005     }
1006     while (nCount > 0) {
1007       int32_t temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
1008       DataList list;
1009       list.data = FX_Alloc2D(uint8_t, temp_count, unit);
1010       list.start = nStart;
1011       list.count = temp_count;
1012       Append(list);
1013       nCount -= temp_count;
1014       nStart += temp_count;
1015     }
1016   }
1017
1018   uint8_t* GetAt(int32_t nIndex) {
1019     if (nIndex < 0) {
1020       return NULL;
1021     }
1022     if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) {
1023       return NULL;
1024     }
1025     DataList* pCurList = m_DataLists.GetDataPtr(m_CurList);
1026     if (!pCurList || nIndex < pCurList->start ||
1027         nIndex >= pCurList->start + pCurList->count) {
1028       pCurList = NULL;
1029       int32_t iStart = 0;
1030       int32_t iEnd = m_DataLists.GetUpperBound();
1031       int32_t iMid = 0;
1032       while (iStart <= iEnd) {
1033         iMid = (iStart + iEnd) / 2;
1034         DataList* list = m_DataLists.GetDataPtr(iMid);
1035         if (nIndex < list->start) {
1036           iEnd = iMid - 1;
1037         } else if (nIndex >= list->start + list->count) {
1038           iStart = iMid + 1;
1039         } else {
1040           pCurList = list;
1041           m_CurList = iMid;
1042           break;
1043         }
1044       }
1045     }
1046     return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;
1047   }
1048
1049  protected:
1050   void Append(const DataList& list) {
1051     int32_t iStart = 0;
1052     int32_t iEnd = m_DataLists.GetUpperBound();
1053     int32_t iFind = 0;
1054     while (iStart <= iEnd) {
1055       int32_t iMid = (iStart + iEnd) / 2;
1056       DataList* cur_list = m_DataLists.GetDataPtr(iMid);
1057       if (list.start < cur_list->start + cur_list->count) {
1058         iEnd = iMid - 1;
1059       } else {
1060         if (iMid == iEnd) {
1061           iFind = iMid + 1;
1062           break;
1063         }
1064         DataList* next_list = m_DataLists.GetDataPtr(iMid + 1);
1065         if (list.start < next_list->start) {
1066           iFind = iMid + 1;
1067           break;
1068         } else {
1069           iStart = iMid + 1;
1070         }
1071       }
1072     }
1073     m_DataLists.InsertAt(iFind, list);
1074   }
1075   int32_t m_CurList;
1076   CFX_ArrayTemplate<DataList> m_DataLists;
1077 };
1078 template <typename T1, typename T2>
1079 class CFX_ListArrayTemplate {
1080  public:
1081   void Clear() { m_Data.Clear(); }
1082
1083   void Add(int32_t nStart, int32_t nCount) { m_Data.Append(nStart, nCount); }
1084
1085   T2& operator[](int32_t nIndex) {
1086     uint8_t* data = m_Data.GetAt(nIndex);
1087     FXSYS_assert(data != NULL);
1088     return (T2&)(*(volatile T2*)data);
1089   }
1090
1091   T2* GetPtrAt(int32_t nIndex) { return (T2*)m_Data.GetAt(nIndex); }
1092
1093  protected:
1094   T1 m_Data;
1095 };
1096 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_FILESIZE)>,
1097                               FX_FILESIZE> CFX_FileSizeListArray;
1098 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_DWORD)>, FX_DWORD>
1099     CFX_DWordListArray;
1100 typedef enum {
1101   Ready,
1102   ToBeContinued,
1103   Found,
1104   NotFound,
1105   Failed,
1106   Done
1107 } FX_ProgressiveStatus;
1108 #define ProgressiveStatus FX_ProgressiveStatus
1109 #define FX_NAMESPACE_DECLARE(namespace, type) namespace ::type
1110
1111 class CFX_Vector_3by1 {
1112  public:
1113   CFX_Vector_3by1() : a(0.0f), b(0.0f), c(0.0f) {}
1114
1115   CFX_Vector_3by1(FX_FLOAT a1, FX_FLOAT b1, FX_FLOAT c1)
1116       : a(a1), b(b1), c(c1) {}
1117
1118   FX_FLOAT a;
1119   FX_FLOAT b;
1120   FX_FLOAT c;
1121 };
1122 class CFX_Matrix_3by3 {
1123  public:
1124   CFX_Matrix_3by3()
1125       : a(0.0f),
1126         b(0.0f),
1127         c(0.0f),
1128         d(0.0f),
1129         e(0.0f),
1130         f(0.0f),
1131         g(0.0f),
1132         h(0.0f),
1133         i(0.0f) {}
1134
1135   CFX_Matrix_3by3(FX_FLOAT a1,
1136                   FX_FLOAT b1,
1137                   FX_FLOAT c1,
1138                   FX_FLOAT d1,
1139                   FX_FLOAT e1,
1140                   FX_FLOAT f1,
1141                   FX_FLOAT g1,
1142                   FX_FLOAT h1,
1143                   FX_FLOAT i1)
1144       : a(a1), b(b1), c(c1), d(d1), e(e1), f(f1), g(g1), h(h1), i(i1) {}
1145
1146   CFX_Matrix_3by3 Inverse();
1147
1148   CFX_Matrix_3by3 Multiply(const CFX_Matrix_3by3& m);
1149
1150   CFX_Vector_3by1 TransformVector(const CFX_Vector_3by1& v);
1151
1152   FX_FLOAT a;
1153   FX_FLOAT b;
1154   FX_FLOAT c;
1155   FX_FLOAT d;
1156   FX_FLOAT e;
1157   FX_FLOAT f;
1158   FX_FLOAT g;
1159   FX_FLOAT h;
1160   FX_FLOAT i;
1161 };
1162
1163 #endif  // CORE_INCLUDE_FXCRT_FX_BASIC_H_