clang-format all pdfium code.
[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
168   FX_BOOL AttachFile(IFX_StreamWrite* pFile, FX_BOOL bTakeover = FALSE);
169
170   FX_BOOL AttachFile(const FX_WCHAR* filename);
171
172   FX_BOOL AttachFile(const FX_CHAR* filename);
173
174  private:
175   FX_BOOL DoWork(const void* pBuf, size_t size) override;
176
177   IFX_StreamWrite* m_pFile;
178
179   FX_BOOL m_bTakeover;
180 };
181
182 struct CFX_CharMap {
183   static CFX_CharMap* GetDefaultMapper(int32_t codepage = 0);
184
185   CFX_WideString (*m_GetWideString)(CFX_CharMap* pMap,
186                                     const CFX_ByteString& bstr);
187
188   CFX_ByteString (*m_GetByteString)(CFX_CharMap* pMap,
189                                     const CFX_WideString& wstr);
190
191   int32_t (*m_GetCodePage)();
192 };
193 class CFX_UTF8Decoder {
194  public:
195   CFX_UTF8Decoder() { m_PendingBytes = 0; }
196
197   void Clear();
198
199   void Input(uint8_t byte);
200
201   void AppendChar(FX_DWORD ch);
202
203   void ClearStatus() { m_PendingBytes = 0; }
204
205   CFX_WideStringC GetResult() const { return m_Buffer.GetWideString(); }
206
207  protected:
208   int m_PendingBytes;
209
210   FX_DWORD m_PendingChar;
211
212   CFX_WideTextBuf m_Buffer;
213 };
214 class CFX_UTF8Encoder {
215  public:
216   CFX_UTF8Encoder() { m_UTF16First = 0; }
217
218   void Input(FX_WCHAR unicode);
219
220   void AppendStr(const CFX_ByteStringC& str) {
221     m_UTF16First = 0;
222     m_Buffer << str;
223   }
224
225   CFX_ByteStringC GetResult() const { return m_Buffer.GetByteString(); }
226
227  protected:
228   CFX_ByteTextBuf m_Buffer;
229
230   FX_DWORD m_UTF16First;
231 };
232 CFX_ByteString FX_UrlEncode(const CFX_WideString& wsUrl);
233 CFX_WideString FX_UrlDecode(const CFX_ByteString& bsUrl);
234 CFX_ByteString FX_EncodeURI(const CFX_WideString& wsURI);
235 CFX_WideString FX_DecodeURI(const CFX_ByteString& bsURI);
236 class CFX_BasicArray {
237  protected:
238   CFX_BasicArray(int unit_size);
239
240   ~CFX_BasicArray();
241
242   FX_BOOL SetSize(int nNewSize);
243
244   FX_BOOL Append(const CFX_BasicArray& src);
245
246   FX_BOOL Copy(const CFX_BasicArray& src);
247
248   uint8_t* InsertSpaceAt(int nIndex, int nCount);
249
250   FX_BOOL RemoveAt(int nIndex, int nCount);
251
252   FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
253
254   const void* GetDataPtr(int index) const;
255
256  protected:
257   uint8_t* m_pData;
258
259   int m_nSize;
260
261   int m_nMaxSize;
262
263   int m_nUnitSize;
264 };
265 template <class TYPE>
266 class CFX_ArrayTemplate : public CFX_BasicArray {
267  public:
268   CFX_ArrayTemplate() : CFX_BasicArray(sizeof(TYPE)) {}
269
270   int GetSize() const { return m_nSize; }
271
272   int GetUpperBound() const { return m_nSize - 1; }
273
274   FX_BOOL SetSize(int nNewSize) { return CFX_BasicArray::SetSize(nNewSize); }
275
276   void RemoveAll() { SetSize(0); }
277
278   const TYPE GetAt(int nIndex) const {
279     if (nIndex < 0 || nIndex >= m_nSize) {
280       return (const TYPE&)(*(volatile const TYPE*)NULL);
281     }
282     return ((const TYPE*)m_pData)[nIndex];
283   }
284
285   FX_BOOL SetAt(int nIndex, TYPE newElement) {
286     if (nIndex < 0 || nIndex >= m_nSize) {
287       return FALSE;
288     }
289     ((TYPE*)m_pData)[nIndex] = newElement;
290     return TRUE;
291   }
292
293   TYPE& ElementAt(int nIndex) {
294     if (nIndex < 0 || nIndex >= m_nSize) {
295       return *(TYPE*)NULL;
296     }
297     return ((TYPE*)m_pData)[nIndex];
298   }
299
300   const TYPE* GetData() const { return (const TYPE*)m_pData; }
301
302   TYPE* GetData() { return (TYPE*)m_pData; }
303
304   FX_BOOL SetAtGrow(int nIndex, TYPE newElement) {
305     if (nIndex < 0) {
306       return FALSE;
307     }
308     if (nIndex >= m_nSize)
309       if (!SetSize(nIndex + 1)) {
310         return FALSE;
311       }
312     ((TYPE*)m_pData)[nIndex] = newElement;
313     return TRUE;
314   }
315
316   FX_BOOL Add(TYPE newElement) {
317     if (m_nSize < m_nMaxSize) {
318       m_nSize++;
319     } else if (!SetSize(m_nSize + 1)) {
320       return FALSE;
321     }
322     ((TYPE*)m_pData)[m_nSize - 1] = newElement;
323     return TRUE;
324   }
325
326   FX_BOOL Append(const CFX_ArrayTemplate& src) {
327     return CFX_BasicArray::Append(src);
328   }
329
330   FX_BOOL Copy(const CFX_ArrayTemplate& src) {
331     return CFX_BasicArray::Copy(src);
332   }
333
334   TYPE* GetDataPtr(int index) {
335     return (TYPE*)CFX_BasicArray::GetDataPtr(index);
336   }
337
338   TYPE* AddSpace() { return (TYPE*)CFX_BasicArray::InsertSpaceAt(m_nSize, 1); }
339
340   TYPE* InsertSpaceAt(int nIndex, int nCount) {
341     return (TYPE*)CFX_BasicArray::InsertSpaceAt(nIndex, nCount);
342   }
343
344   const TYPE operator[](int nIndex) const {
345     if (nIndex < 0 || nIndex >= m_nSize) {
346       *(volatile char*)0 = '\0';
347     }
348     return ((const TYPE*)m_pData)[nIndex];
349   }
350
351   TYPE& operator[](int nIndex) {
352     if (nIndex < 0 || nIndex >= m_nSize) {
353       *(volatile char*)0 = '\0';
354     }
355     return ((TYPE*)m_pData)[nIndex];
356   }
357
358   FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount = 1) {
359     if (!InsertSpaceAt(nIndex, nCount)) {
360       return FALSE;
361     }
362     while (nCount--) {
363       ((TYPE*)m_pData)[nIndex++] = newElement;
364     }
365     return TRUE;
366   }
367
368   FX_BOOL RemoveAt(int nIndex, int nCount = 1) {
369     return CFX_BasicArray::RemoveAt(nIndex, nCount);
370   }
371
372   FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray) {
373     return CFX_BasicArray::InsertAt(nStartIndex, pNewArray);
374   }
375
376   int Find(TYPE data, int iStart = 0) const {
377     if (iStart < 0) {
378       return -1;
379     }
380     for (; iStart < (int)m_nSize; iStart++)
381       if (((TYPE*)m_pData)[iStart] == data) {
382         return iStart;
383       }
384     return -1;
385   }
386 };
387 typedef CFX_ArrayTemplate<uint8_t> CFX_ByteArray;
388 typedef CFX_ArrayTemplate<FX_WORD> CFX_WordArray;
389 typedef CFX_ArrayTemplate<FX_DWORD> CFX_DWordArray;
390 typedef CFX_ArrayTemplate<void*> CFX_PtrArray;
391 typedef CFX_ArrayTemplate<FX_FILESIZE> CFX_FileSizeArray;
392 typedef CFX_ArrayTemplate<FX_FLOAT> CFX_FloatArray;
393 typedef CFX_ArrayTemplate<int32_t> CFX_Int32Array;
394 template <class ObjectClass>
395 class CFX_ObjectArray : public CFX_BasicArray {
396  public:
397   CFX_ObjectArray() : CFX_BasicArray(sizeof(ObjectClass)) {}
398
399   ~CFX_ObjectArray() { RemoveAll(); }
400
401   void Add(const ObjectClass& data) {
402     new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
403   }
404
405   ObjectClass& Add() {
406     return *(ObjectClass*)new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
407   }
408
409   void* AddSpace() { return InsertSpaceAt(m_nSize, 1); }
410
411   int32_t Append(const CFX_ObjectArray& src,
412                  int32_t nStart = 0,
413                  int32_t nCount = -1) {
414     if (nCount == 0) {
415       return 0;
416     }
417     int32_t nSize = src.GetSize();
418     if (!nSize) {
419       return 0;
420     }
421     FXSYS_assert(nStart > -1 && nStart < nSize);
422     if (nCount < 0) {
423       nCount = nSize;
424     }
425     if (nStart + nCount > nSize) {
426       nCount = nSize - nStart;
427     }
428     if (nCount < 1) {
429       return 0;
430     }
431     nSize = m_nSize;
432     InsertSpaceAt(m_nSize, nCount);
433     ObjectClass* pStartObj = (ObjectClass*)GetDataPtr(nSize);
434     nSize = nStart + nCount;
435     for (int32_t i = nStart; i < nSize; i++, pStartObj++) {
436       new ((void*)pStartObj) ObjectClass(src[i]);
437     }
438     return nCount;
439   }
440
441   int32_t Copy(const CFX_ObjectArray& src,
442                int32_t nStart = 0,
443                int32_t nCount = -1) {
444     if (nCount == 0) {
445       return 0;
446     }
447     int32_t nSize = src.GetSize();
448     if (!nSize) {
449       return 0;
450     }
451     FXSYS_assert(nStart > -1 && nStart < nSize);
452     if (nCount < 0) {
453       nCount = nSize;
454     }
455     if (nStart + nCount > nSize) {
456       nCount = nSize - nStart;
457     }
458     if (nCount < 1) {
459       return 0;
460     }
461     RemoveAll();
462     SetSize(nCount);
463     ObjectClass* pStartObj = (ObjectClass*)m_pData;
464     nSize = nStart + nCount;
465     for (int32_t i = nStart; i < nSize; i++, pStartObj++) {
466       new ((void*)pStartObj) ObjectClass(src[i]);
467     }
468     return nCount;
469   }
470
471   int GetSize() const { return m_nSize; }
472
473   ObjectClass& operator[](int index) const {
474     FXSYS_assert(index < m_nSize);
475     return *(ObjectClass*)CFX_BasicArray::GetDataPtr(index);
476   }
477
478   ObjectClass* GetDataPtr(int index) {
479     return (ObjectClass*)CFX_BasicArray::GetDataPtr(index);
480   }
481
482   void RemoveAt(int index) {
483     FXSYS_assert(index < m_nSize);
484     ((ObjectClass*)GetDataPtr(index))->~ObjectClass();
485     CFX_BasicArray::RemoveAt(index, 1);
486   }
487
488   void RemoveAll() {
489     for (int i = 0; i < m_nSize; i++) {
490       ((ObjectClass*)GetDataPtr(i))->~ObjectClass();
491     }
492     CFX_BasicArray::SetSize(0);
493   }
494 };
495 typedef CFX_ObjectArray<CFX_ByteString> CFX_ByteStringArray;
496 typedef CFX_ObjectArray<CFX_WideString> CFX_WideStringArray;
497 class CFX_BaseSegmentedArray {
498  public:
499   CFX_BaseSegmentedArray(int unit_size = 1,
500                          int segment_units = 512,
501                          int index_size = 8);
502
503   ~CFX_BaseSegmentedArray();
504
505   void SetUnitSize(int unit_size, int segment_units, int index_size = 8);
506
507   void* Add();
508
509   void* GetAt(int index) const;
510
511   void RemoveAll();
512
513   void Delete(int index, int count = 1);
514
515   int GetSize() const { return m_DataSize; }
516
517   int GetSegmentSize() const { return m_SegmentSize; }
518
519   int GetUnitSize() const { return m_UnitSize; }
520
521   void* Iterate(FX_BOOL (*callback)(void* param, void* pData),
522                 void* param) const;
523
524  private:
525   int m_UnitSize;
526
527   short m_SegmentSize;
528
529   uint8_t m_IndexSize;
530
531   uint8_t m_IndexDepth;
532
533   int m_DataSize;
534
535   void* m_pIndex;
536   void** GetIndex(int seg_index) const;
537   void* IterateIndex(int level,
538                      int& start,
539                      void** pIndex,
540                      FX_BOOL (*callback)(void* param, void* pData),
541                      void* param) const;
542   void* IterateSegment(const uint8_t* pSegment,
543                        int count,
544                        FX_BOOL (*callback)(void* param, void* pData),
545                        void* param) const;
546 };
547 template <class ElementType>
548 class CFX_SegmentedArray : public CFX_BaseSegmentedArray {
549  public:
550   CFX_SegmentedArray(int segment_units, int index_size = 8)
551       : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size) {
552   }
553
554   void Add(ElementType data) {
555     *(ElementType*)CFX_BaseSegmentedArray::Add() = data;
556   }
557
558   ElementType& operator[](int index) {
559     return *(ElementType*)CFX_BaseSegmentedArray::GetAt(index);
560   }
561 };
562 template <class DataType, int FixedSize>
563 class CFX_FixedBufGrow {
564  public:
565   CFX_FixedBufGrow() : m_pData(NULL) {}
566   CFX_FixedBufGrow(int data_size) : m_pData(NULL) {
567     if (data_size > FixedSize) {
568       m_pData = FX_Alloc(DataType, data_size);
569     } else {
570       FXSYS_memset(m_Data, 0, sizeof(DataType) * FixedSize);
571     }
572   }
573   void SetDataSize(int data_size) {
574     if (m_pData) {
575       FX_Free(m_pData);
576     }
577     m_pData = NULL;
578     if (data_size > FixedSize) {
579       m_pData = FX_Alloc(DataType, data_size);
580     } else {
581       FXSYS_memset(m_Data, 0, sizeof(DataType) * FixedSize);
582     }
583   }
584   ~CFX_FixedBufGrow() {
585     if (m_pData) {
586       FX_Free(m_pData);
587     }
588   }
589   operator DataType*() { return m_pData ? m_pData : m_Data; }
590
591  private:
592   DataType m_Data[FixedSize];
593   DataType* m_pData;
594 };
595 class CFX_MapPtrToPtr {
596  protected:
597   struct CAssoc {
598     CAssoc* pNext;
599
600     void* key;
601
602     void* value;
603   };
604
605  public:
606   CFX_MapPtrToPtr(int nBlockSize = 10);
607
608   ~CFX_MapPtrToPtr();
609
610   int GetCount() const { return m_nCount; }
611
612   FX_BOOL IsEmpty() const { return m_nCount == 0; }
613
614   FX_BOOL Lookup(void* key, void*& rValue) const;
615
616   void* GetValueAt(void* key) const;
617
618   void*& operator[](void* key);
619
620   void SetAt(void* key, void* newValue) { (*this)[key] = newValue; }
621
622   FX_BOOL RemoveKey(void* key);
623
624   void RemoveAll();
625
626   FX_POSITION GetStartPosition() const {
627     return (m_nCount == 0) ? NULL : (FX_POSITION)-1;
628   }
629
630   void GetNextAssoc(FX_POSITION& rNextPosition,
631                     void*& rKey,
632                     void*& rValue) const;
633
634   FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
635
636   void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
637
638  protected:
639   CAssoc** m_pHashTable;
640
641   FX_DWORD m_nHashTableSize;
642
643   int m_nCount;
644
645   CAssoc* m_pFreeList;
646
647   struct CFX_Plex* m_pBlocks;
648
649   int m_nBlockSize;
650
651   FX_DWORD HashKey(void* key) const;
652
653   CAssoc* NewAssoc();
654
655   void FreeAssoc(CAssoc* pAssoc);
656
657   CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
658 };
659
660 class CFX_CMapDWordToDWord {
661  public:
662   FX_BOOL Lookup(FX_DWORD key, FX_DWORD& value) const;
663
664   void SetAt(FX_DWORD key, FX_DWORD value);
665
666   void EstimateSize(FX_DWORD size, FX_DWORD grow_by);
667
668   FX_POSITION GetStartPosition() const;
669
670   void GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;
671
672  protected:
673   CFX_BinaryBuf m_Buffer;
674 };
675 class CFX_MapByteStringToPtr {
676  protected:
677   struct CAssoc {
678     CAssoc* pNext;
679
680     FX_DWORD nHashValue;
681
682     CFX_ByteString key;
683
684     void* value;
685   };
686
687  public:
688   CFX_MapByteStringToPtr(int nBlockSize = 10);
689
690   int GetCount() const { return m_nCount; }
691
692   FX_BOOL IsEmpty() const { return m_nCount == 0; }
693
694   FX_BOOL Lookup(const CFX_ByteStringC& key, void*& rValue) const;
695
696   void*& operator[](const CFX_ByteStringC& key);
697
698   void SetAt(const CFX_ByteStringC& key, void* newValue) {
699     (*this)[key] = newValue;
700   }
701
702   FX_BOOL RemoveKey(const CFX_ByteStringC& key);
703
704   void RemoveAll();
705
706   FX_POSITION GetStartPosition() const {
707     return (m_nCount == 0) ? NULL : (FX_POSITION)-1;
708   }
709
710   void GetNextAssoc(FX_POSITION& rNextPosition,
711                     CFX_ByteString& rKey,
712                     void*& rValue) const;
713
714   void* GetNextValue(FX_POSITION& rNextPosition) const;
715
716   FX_DWORD GetHashTableSize() const { return m_nHashTableSize; }
717
718   void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
719
720   FX_DWORD HashKey(const CFX_ByteStringC& key) const;
721
722  protected:
723   CAssoc** m_pHashTable;
724
725   FX_DWORD m_nHashTableSize;
726
727   int m_nCount;
728
729   CAssoc* m_pFreeList;
730
731   struct CFX_Plex* m_pBlocks;
732
733   int m_nBlockSize;
734
735   CAssoc* NewAssoc();
736
737   void FreeAssoc(CAssoc* pAssoc);
738
739   CAssoc* GetAssocAt(const CFX_ByteStringC& key, FX_DWORD& hash) const;
740
741  public:
742   ~CFX_MapByteStringToPtr();
743 };
744 class CFX_CMapByteStringToPtr {
745  public:
746   CFX_CMapByteStringToPtr();
747
748   ~CFX_CMapByteStringToPtr();
749
750   void RemoveAll();
751
752   FX_POSITION GetStartPosition() const;
753
754   void GetNextAssoc(FX_POSITION& rNextPosition,
755                     CFX_ByteString& rKey,
756                     void*& rValue) const;
757
758   void* GetNextValue(FX_POSITION& rNextPosition) const;
759
760   FX_BOOL Lookup(const CFX_ByteStringC& key, void*& rValue) const;
761
762   void SetAt(const CFX_ByteStringC& key, void* value);
763
764   void RemoveKey(const CFX_ByteStringC& key);
765
766   int GetCount() const;
767
768   void AddValue(const CFX_ByteStringC& key, void* pValue);
769
770  private:
771   CFX_BaseSegmentedArray m_Buffer;
772 };
773 class CFX_PtrList {
774  protected:
775   struct CNode {
776     CNode* pNext;
777
778     CNode* pPrev;
779
780     void* data;
781   };
782
783  public:
784   CFX_PtrList(int nBlockSize = 10);
785
786   FX_POSITION GetHeadPosition() const { return (FX_POSITION)m_pNodeHead; }
787
788   FX_POSITION GetTailPosition() const { return (FX_POSITION)m_pNodeTail; }
789
790   void* GetNext(FX_POSITION& rPosition) const {
791     CNode* pNode = (CNode*)rPosition;
792     rPosition = (FX_POSITION)pNode->pNext;
793     return pNode->data;
794   }
795
796   void* GetPrev(FX_POSITION& rPosition) const {
797     CNode* pNode = (CNode*)rPosition;
798     rPosition = (FX_POSITION)pNode->pPrev;
799     return pNode->data;
800   }
801
802   FX_POSITION GetNextPosition(FX_POSITION pos) const {
803     return ((CNode*)pos)->pNext;
804   }
805
806   FX_POSITION GetPrevPosition(FX_POSITION pos) const {
807     return ((CNode*)pos)->pPrev;
808   }
809
810   void* GetAt(FX_POSITION rPosition) const {
811     CNode* pNode = (CNode*)rPosition;
812     return pNode->data;
813   }
814
815   int GetCount() const { return m_nCount; }
816
817   FX_POSITION AddTail(void* newElement);
818
819   FX_POSITION AddHead(void* newElement);
820
821   void SetAt(FX_POSITION pos, void* newElement) {
822     CNode* pNode = (CNode*)pos;
823     pNode->data = newElement;
824   }
825
826   FX_POSITION InsertAfter(FX_POSITION pos, void* newElement);
827
828   FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL) const;
829
830   FX_POSITION FindIndex(int index) const;
831
832   void RemoveAt(FX_POSITION pos);
833
834   void RemoveAll();
835
836  protected:
837   CNode* m_pNodeHead;
838
839   CNode* m_pNodeTail;
840
841   int m_nCount;
842
843   CNode* m_pNodeFree;
844
845   struct CFX_Plex* m_pBlocks;
846
847   int m_nBlockSize;
848
849   CNode* NewNode(CNode* pPrev, CNode* pNext);
850
851   void FreeNode(CNode* pNode);
852
853  public:
854   ~CFX_PtrList();
855 };
856 typedef void (*PD_CALLBACK_FREEDATA)(void* pData);
857 struct FX_PRIVATEDATA {
858   void FreeData();
859
860   void* m_pModuleId;
861
862   void* m_pData;
863
864   PD_CALLBACK_FREEDATA m_pCallback;
865
866   FX_BOOL m_bSelfDestruct;
867 };
868 class CFX_PrivateData {
869  public:
870   ~CFX_PrivateData();
871
872   void ClearAll();
873
874   void SetPrivateData(void* module_id,
875                       void* pData,
876                       PD_CALLBACK_FREEDATA callback);
877
878   void SetPrivateObj(void* module_id, CFX_DestructObject* pObj);
879
880   void* GetPrivateData(void* module_id);
881
882   FX_BOOL LookupPrivateData(void* module_id, void*& pData) const {
883     if (!module_id) {
884       return FALSE;
885     }
886     FX_DWORD nCount = m_DataList.GetSize();
887     for (FX_DWORD n = 0; n < nCount; n++) {
888       if (m_DataList[n].m_pModuleId == module_id) {
889         pData = m_DataList[n].m_pData;
890         return TRUE;
891       }
892     }
893     return FALSE;
894   }
895
896   FX_BOOL RemovePrivateData(void* module_id);
897
898  protected:
899   CFX_ArrayTemplate<FX_PRIVATEDATA> m_DataList;
900
901   void AddData(void* module_id,
902                void* pData,
903                PD_CALLBACK_FREEDATA callback,
904                FX_BOOL bSelfDestruct);
905 };
906 class CFX_BitStream {
907  public:
908   void Init(const uint8_t* pData, FX_DWORD dwSize);
909
910   FX_DWORD GetBits(FX_DWORD nBits);
911
912   void ByteAlign();
913
914   FX_BOOL IsEOF() { return m_BitPos >= m_BitSize; }
915
916   void SkipBits(FX_DWORD nBits) { m_BitPos += nBits; }
917
918   void Rewind() { m_BitPos = 0; }
919
920  protected:
921   FX_DWORD m_BitPos;
922
923   FX_DWORD m_BitSize;
924
925   const uint8_t* m_pData;
926 };
927 template <class ObjClass>
928 class CFX_CountRef {
929  public:
930   typedef CFX_CountRef<ObjClass> Ref;
931
932   class CountedObj : public ObjClass {
933    public:
934     CountedObj() {}
935
936     CountedObj(const CountedObj& src) : ObjClass(src) {}
937
938     int m_RefCount;
939   };
940
941   CFX_CountRef() { m_pObject = NULL; }
942
943   CFX_CountRef(const Ref& ref) {
944     m_pObject = ref.m_pObject;
945     if (m_pObject) {
946       m_pObject->m_RefCount++;
947     }
948   }
949
950   ~CFX_CountRef() {
951     if (!m_pObject) {
952       return;
953     }
954     m_pObject->m_RefCount--;
955     if (m_pObject->m_RefCount <= 0) {
956       delete m_pObject;
957     }
958   }
959
960   ObjClass* New() {
961     if (m_pObject) {
962       m_pObject->m_RefCount--;
963       if (m_pObject->m_RefCount <= 0) {
964         delete m_pObject;
965       }
966     }
967     m_pObject = new CountedObj;
968     m_pObject->m_RefCount = 1;
969     return m_pObject;
970   }
971
972   void operator=(const Ref& ref) {
973     if (ref.m_pObject) {
974       ref.m_pObject->m_RefCount++;
975     }
976     if (m_pObject) {
977       m_pObject->m_RefCount--;
978       if (m_pObject->m_RefCount <= 0) {
979         delete m_pObject;
980       }
981     }
982     m_pObject = ref.m_pObject;
983   }
984
985   void operator=(void* p) {
986     FXSYS_assert(p == 0);
987     if (m_pObject == NULL) {
988       return;
989     }
990     m_pObject->m_RefCount--;
991     if (m_pObject->m_RefCount <= 0) {
992       delete m_pObject;
993     }
994     m_pObject = NULL;
995   }
996
997   const ObjClass* GetObject() const { return m_pObject; }
998
999   operator const ObjClass*() const { return m_pObject; }
1000
1001   FX_BOOL IsNull() const { return m_pObject == NULL; }
1002
1003   FX_BOOL NotNull() const { return m_pObject != NULL; }
1004
1005   ObjClass* GetModify() {
1006     if (m_pObject == NULL) {
1007       m_pObject = new CountedObj;
1008       m_pObject->m_RefCount = 1;
1009     } else if (m_pObject->m_RefCount > 1) {
1010       m_pObject->m_RefCount--;
1011       CountedObj* pOldObject = m_pObject;
1012       m_pObject = new CountedObj(*pOldObject);
1013       m_pObject->m_RefCount = 1;
1014     }
1015     return m_pObject;
1016   }
1017
1018   void SetNull() {
1019     if (m_pObject == NULL) {
1020       return;
1021     }
1022     m_pObject->m_RefCount--;
1023     if (m_pObject->m_RefCount <= 0) {
1024       delete m_pObject;
1025     }
1026     m_pObject = NULL;
1027   }
1028
1029   FX_BOOL operator==(const Ref& ref) const {
1030     return m_pObject == ref.m_pObject;
1031   }
1032
1033  protected:
1034   CountedObj* m_pObject;
1035 };
1036 class IFX_Pause {
1037  public:
1038   virtual ~IFX_Pause() {}
1039   virtual FX_BOOL NeedToPauseNow() = 0;
1040 };
1041 class CFX_DataFilter {
1042  public:
1043   virtual ~CFX_DataFilter();
1044
1045   void SetDestFilter(CFX_DataFilter* pFilter);
1046
1047   FX_BOOL IsEOF() const { return m_bEOF; }
1048
1049   FX_DWORD GetSrcPos() { return m_SrcPos; }
1050
1051   void FilterIn(const uint8_t* src_buf,
1052                 FX_DWORD src_size,
1053                 CFX_BinaryBuf& dest_buf);
1054
1055   void FilterFinish(CFX_BinaryBuf& dest_buf);
1056
1057  protected:
1058   CFX_DataFilter();
1059   virtual void v_FilterIn(const uint8_t* src_buf,
1060                           FX_DWORD src_size,
1061                           CFX_BinaryBuf& dest_buf) = 0;
1062   virtual void v_FilterFinish(CFX_BinaryBuf& dest_buf) = 0;
1063   void ReportEOF(FX_DWORD left_input);
1064
1065   FX_BOOL m_bEOF;
1066
1067   FX_DWORD m_SrcPos;
1068
1069   CFX_DataFilter* m_pDestFilter;
1070 };
1071
1072 template <typename T>
1073 class CFX_AutoRestorer {
1074  public:
1075   explicit CFX_AutoRestorer(T* location) {
1076     m_Location = location;
1077     m_OldValue = *location;
1078   }
1079   ~CFX_AutoRestorer() { *m_Location = m_OldValue; }
1080
1081  private:
1082   T* m_Location;
1083   T m_OldValue;
1084 };
1085
1086 template <class T>
1087 class CFX_SmartPointer {
1088  public:
1089   CFX_SmartPointer(T* pObj) : m_pObj(pObj) {}
1090   ~CFX_SmartPointer() { m_pObj->Release(); }
1091   T* Get(void) { return m_pObj; }
1092   T& operator*(void) { return *m_pObj; }
1093   T* operator->(void) { return m_pObj; }
1094
1095  protected:
1096   T* m_pObj;
1097 };
1098 #define FX_DATALIST_LENGTH 1024
1099 template <size_t unit>
1100 class CFX_SortListArray {
1101  protected:
1102   struct DataList {
1103     int32_t start;
1104
1105     int32_t count;
1106     uint8_t* data;
1107   };
1108
1109  public:
1110   CFX_SortListArray() : m_CurList(0) {}
1111
1112   ~CFX_SortListArray() { Clear(); }
1113
1114   void Clear() {
1115     for (int32_t i = m_DataLists.GetUpperBound(); i >= 0; i--) {
1116       DataList list = m_DataLists.ElementAt(i);
1117       if (list.data) {
1118         FX_Free(list.data);
1119       }
1120     }
1121     m_DataLists.RemoveAll();
1122     m_CurList = 0;
1123   }
1124
1125   void Append(int32_t nStart, int32_t nCount) {
1126     if (nStart < 0) {
1127       return;
1128     }
1129     while (nCount > 0) {
1130       int32_t temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
1131       DataList list;
1132       list.data = FX_Alloc2D(uint8_t, temp_count, unit);
1133       list.start = nStart;
1134       list.count = temp_count;
1135       Append(list);
1136       nCount -= temp_count;
1137       nStart += temp_count;
1138     }
1139   }
1140
1141   uint8_t* GetAt(int32_t nIndex) {
1142     if (nIndex < 0) {
1143       return NULL;
1144     }
1145     if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) {
1146       return NULL;
1147     }
1148     DataList* pCurList = m_DataLists.GetDataPtr(m_CurList);
1149     if (!pCurList || nIndex < pCurList->start ||
1150         nIndex >= pCurList->start + pCurList->count) {
1151       pCurList = NULL;
1152       int32_t iStart = 0;
1153       int32_t iEnd = m_DataLists.GetUpperBound();
1154       int32_t iMid = 0;
1155       while (iStart <= iEnd) {
1156         iMid = (iStart + iEnd) / 2;
1157         DataList* list = m_DataLists.GetDataPtr(iMid);
1158         if (nIndex < list->start) {
1159           iEnd = iMid - 1;
1160         } else if (nIndex >= list->start + list->count) {
1161           iStart = iMid + 1;
1162         } else {
1163           pCurList = list;
1164           m_CurList = iMid;
1165           break;
1166         }
1167       }
1168     }
1169     return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;
1170   }
1171
1172  protected:
1173   void Append(const DataList& list) {
1174     int32_t iStart = 0;
1175     int32_t iEnd = m_DataLists.GetUpperBound();
1176     int32_t iFind = 0;
1177     while (iStart <= iEnd) {
1178       int32_t iMid = (iStart + iEnd) / 2;
1179       DataList* cur_list = m_DataLists.GetDataPtr(iMid);
1180       if (list.start < cur_list->start + cur_list->count) {
1181         iEnd = iMid - 1;
1182       } else {
1183         if (iMid == iEnd) {
1184           iFind = iMid + 1;
1185           break;
1186         }
1187         DataList* next_list = m_DataLists.GetDataPtr(iMid + 1);
1188         if (list.start < next_list->start) {
1189           iFind = iMid + 1;
1190           break;
1191         } else {
1192           iStart = iMid + 1;
1193         }
1194       }
1195     }
1196     m_DataLists.InsertAt(iFind, list);
1197   }
1198   int32_t m_CurList;
1199   CFX_ArrayTemplate<DataList> m_DataLists;
1200 };
1201 template <typename T1, typename T2>
1202 class CFX_ListArrayTemplate {
1203  public:
1204   void Clear() { m_Data.Clear(); }
1205
1206   void Add(int32_t nStart, int32_t nCount) { m_Data.Append(nStart, nCount); }
1207
1208   T2& operator[](int32_t nIndex) {
1209     uint8_t* data = m_Data.GetAt(nIndex);
1210     FXSYS_assert(data != NULL);
1211     return (T2&)(*(volatile T2*)data);
1212   }
1213
1214   T2* GetPtrAt(int32_t nIndex) { return (T2*)m_Data.GetAt(nIndex); }
1215
1216  protected:
1217   T1 m_Data;
1218 };
1219 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_FILESIZE)>,
1220                               FX_FILESIZE> CFX_FileSizeListArray;
1221 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_DWORD)>, FX_DWORD>
1222     CFX_DWordListArray;
1223 typedef enum {
1224   Ready,
1225   ToBeContinued,
1226   Found,
1227   NotFound,
1228   Failed,
1229   Done
1230 } FX_ProgressiveStatus;
1231 #define ProgressiveStatus FX_ProgressiveStatus
1232 #define FX_NAMESPACE_DECLARE(namespace, type) namespace ::type
1233
1234 class CFX_Vector_3by1 {
1235  public:
1236   CFX_Vector_3by1() : a(0.0f), b(0.0f), c(0.0f) {}
1237
1238   CFX_Vector_3by1(FX_FLOAT a1, FX_FLOAT b1, FX_FLOAT c1)
1239       : a(a1), b(b1), c(c1) {}
1240
1241   FX_FLOAT a;
1242   FX_FLOAT b;
1243   FX_FLOAT c;
1244 };
1245 class CFX_Matrix_3by3 {
1246  public:
1247   CFX_Matrix_3by3()
1248       : a(0.0f),
1249         b(0.0f),
1250         c(0.0f),
1251         d(0.0f),
1252         e(0.0f),
1253         f(0.0f),
1254         g(0.0f),
1255         h(0.0f),
1256         i(0.0f) {}
1257
1258   CFX_Matrix_3by3(FX_FLOAT a1,
1259                   FX_FLOAT b1,
1260                   FX_FLOAT c1,
1261                   FX_FLOAT d1,
1262                   FX_FLOAT e1,
1263                   FX_FLOAT f1,
1264                   FX_FLOAT g1,
1265                   FX_FLOAT h1,
1266                   FX_FLOAT i1)
1267       : a(a1), b(b1), c(c1), d(d1), e(e1), f(f1), g(g1), h(h1), i(i1) {}
1268
1269   CFX_Matrix_3by3 Inverse();
1270
1271   CFX_Matrix_3by3 Multiply(const CFX_Matrix_3by3& m);
1272
1273   CFX_Vector_3by1 TransformVector(const CFX_Vector_3by1& v);
1274
1275   FX_FLOAT a;
1276   FX_FLOAT b;
1277   FX_FLOAT c;
1278   FX_FLOAT d;
1279   FX_FLOAT e;
1280   FX_FLOAT f;
1281   FX_FLOAT g;
1282   FX_FLOAT h;
1283   FX_FLOAT i;
1284 };
1285
1286 #endif  // CORE_INCLUDE_FXCRT_FX_BASIC_H_