Initial commit.

1 files changed, 1642 insertions, 0 deletions

diff --git a/core/include/fxcrt/fx_basic.h b/core/include/fxcrt/fx_basic.h
new file mode 100644
index 0000000000..29bc221e5b
--- /dev/null
+++ b/core/include/fxcrt/fx_basic.h
@@ -0,0 +1,1642 @@
+// Copyright 2014 PDFium Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style license that can be

+// found in the LICENSE file.

+ 

+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

+

+#ifndef _FX_BASIC_H_

+#define _FX_BASIC_H_

+#ifndef _FX_SYSTEM_H_

+#include "fx_system.h"

+#endif

+#ifndef _FX_MEMORY_H_

+#include "fx_memory.h"

+#endif

+#ifndef _FX_STRING_H_

+#include "fx_string.h"

+#endif

+#ifndef _FX_STREAM_H_

+#include "fx_stream.h"

+#endif

+class CFX_BinaryBuf : public CFX_Object

+{

+public:

+

+    CFX_BinaryBuf(IFX_Allocator* pAllocator = NULL);

+

+    CFX_BinaryBuf(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);

+

+    ~CFX_BinaryBuf();

+

+    void					Clear();

+

+    void					EstimateSize(FX_STRSIZE size, FX_STRSIZE alloc_step = 0);

+

+    void					AppendBlock(const void* pBuf, FX_STRSIZE size);

+

+    void					AppendFill(FX_BYTE byte, FX_STRSIZE count);

+

+    void					AppendString(FX_BSTR str)

+    {

+        AppendBlock(str.GetPtr(), str.GetLength());

+    }

+

+    inline void				AppendByte(FX_BYTE byte)

+    {

+        if (m_AllocSize <= m_DataSize) {

+            ExpandBuf(1);

+        }

+        m_pBuffer[m_DataSize++] = byte;

+    }

+

+    void					InsertBlock(FX_STRSIZE pos, const void* pBuf, FX_STRSIZE size);

+

+    void					AttachData(void* pBuf, FX_STRSIZE size);

+

+    void					CopyData(const void* pBuf, FX_STRSIZE size);

+

+    void					TakeOver(CFX_BinaryBuf& other);

+

+    void					Delete(int start_index, int count);

+

+    FX_LPBYTE				GetBuffer() const

+    {

+        return m_pBuffer;

+    }

+

+    FX_STRSIZE				GetSize() const

+    {

+        return m_DataSize;

+    }

+

+    CFX_ByteStringC			GetByteString() const;

+    void					GetByteStringL(CFX_ByteStringL &str) const;

+

+    void					DetachBuffer();

+

+    IFX_Allocator*			m_pAllocator;

+protected:

+

+    FX_STRSIZE				m_AllocStep;

+

+    FX_LPBYTE				m_pBuffer;

+

+    FX_STRSIZE				m_DataSize;

+

+    FX_STRSIZE				m_AllocSize;

+

+    void					ExpandBuf(FX_STRSIZE size);

+};

+class CFX_ByteTextBuf : public CFX_BinaryBuf

+{

+public:

+

+    CFX_ByteTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}

+

+    void					operator = (FX_BSTR str);

+

+    void					AppendChar(int ch)

+    {

+        AppendByte((FX_BYTE)ch);

+    }

+

+    CFX_ByteTextBuf&		operator << (int i);

+

+    CFX_ByteTextBuf&		operator << (FX_DWORD i);

+

+    CFX_ByteTextBuf&		operator << (double f);

+

+    CFX_ByteTextBuf&		operator << (FX_BSTR lpsz);

+

+    CFX_ByteTextBuf&		operator << (const CFX_ByteTextBuf& buf);

+

+    FX_STRSIZE				GetLength() const

+    {

+        return m_DataSize;

+    }

+};

+class CFX_WideTextBuf : public CFX_BinaryBuf

+{

+public:

+

+    CFX_WideTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}

+

+    void					operator = (FX_LPCWSTR lpsz);

+

+    void					operator = (FX_WSTR str);

+

+    void					AppendChar(FX_WCHAR wch);

+

+    CFX_WideTextBuf&		operator << (int i);

+

+    CFX_WideTextBuf&		operator << (double f);

+

+    CFX_WideTextBuf&		operator << (FX_LPCWSTR lpsz);

+

+    CFX_WideTextBuf&		operator << (FX_WSTR str);

+    CFX_WideTextBuf&		operator << (const CFX_WideString &str);

+

+    CFX_WideTextBuf&		operator << (const CFX_WideTextBuf& buf);

+

+    FX_STRSIZE				GetLength() const

+    {

+        return m_DataSize / sizeof(FX_WCHAR);

+    }

+

+    FX_LPWSTR				GetBuffer() const

+    {

+        return (FX_LPWSTR)m_pBuffer;

+    }

+

+    void					Delete(int start_index, int count)

+    {

+        CFX_BinaryBuf::Delete(start_index * sizeof(FX_WCHAR), count * sizeof(FX_WCHAR));

+    }

+

+    CFX_WideStringC			GetWideString() const;

+    void					GetWideStringL(CFX_WideStringL& wideText) const;

+};

+class CFX_ArchiveSaver : public CFX_Object

+{

+public:

+

+    CFX_ArchiveSaver(IFX_Allocator* pAllocator = NULL) : m_SavingBuf(pAllocator), m_pStream(NULL) {}

+

+    CFX_ArchiveSaver&		operator << (FX_BYTE i);

+

+    CFX_ArchiveSaver&		operator << (int i);

+

+    CFX_ArchiveSaver&		operator << (FX_DWORD i);

+

+    CFX_ArchiveSaver&		operator << (FX_FLOAT i);

+

+    CFX_ArchiveSaver&		operator << (double i);

+

+    CFX_ArchiveSaver&		operator << (FX_BSTR bstr);

+

+    CFX_ArchiveSaver&		operator << (FX_LPCWSTR bstr);

+

+    CFX_ArchiveSaver&		operator << (const CFX_WideString& wstr);

+

+    void					Write(const void* pData, FX_STRSIZE dwSize);

+

+    FX_INTPTR				GetLength()

+    {

+        return m_SavingBuf.GetSize();

+    }

+

+    FX_LPCBYTE				GetBuffer()

+    {

+        return m_SavingBuf.GetBuffer();

+    }

+

+    void					SetStream(IFX_FileStream* pStream)

+    {

+        m_pStream = pStream;

+    }

+protected:

+

+    CFX_BinaryBuf			m_SavingBuf;

+

+    IFX_FileStream*			m_pStream;

+};

+class CFX_ArchiveLoader : public CFX_Object

+{

+public:

+

+    CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize);

+

+    CFX_ArchiveLoader&		operator >> (FX_BYTE& i);

+

+    CFX_ArchiveLoader&		operator >> (int& i);

+

+    CFX_ArchiveLoader&		operator >> (FX_DWORD& i);

+

+    CFX_ArchiveLoader&		operator >> (FX_FLOAT& i);

+

+    CFX_ArchiveLoader&		operator >> (double& i);

+

+    CFX_ArchiveLoader&		operator >> (CFX_ByteString& bstr);

+

+    CFX_ArchiveLoader&		operator >> (CFX_WideString& wstr);

+

+    FX_BOOL					IsEOF();

+

+    FX_BOOL					Read(void* pBuf, FX_DWORD dwSize);

+protected:

+

+    FX_DWORD				m_LoadingPos;

+

+    FX_LPCBYTE				m_pLoadingBuf;

+

+    FX_DWORD				m_LoadingSize;

+};

+class IFX_BufferArchive

+{

+public:

+

+    IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);

+

+

+    virtual void			Clear();

+

+

+    FX_BOOL					Flush();

+

+

+    FX_INT32				AppendBlock(const void* pBuf, size_t size);

+

+    FX_INT32				AppendByte(FX_BYTE byte);

+

+    FX_INT32				AppendDWord(FX_DWORD i);

+

+

+    FX_INT32				AppendString(FX_BSTR lpsz);

+

+protected:

+

+    virtual	FX_BOOL			DoWork(const void* pBuf, size_t size) = 0;

+

+

+    IFX_Allocator*			m_pAllocator;

+

+    FX_STRSIZE				m_BufSize;

+

+    FX_LPBYTE				m_pBuffer;

+

+    FX_STRSIZE				m_Length;

+};

+class CFX_FileBufferArchive : public IFX_BufferArchive, public CFX_Object

+{

+public:

+    CFX_FileBufferArchive(FX_STRSIZE size = 32768, IFX_Allocator* pAllocator = NULL);

+    ~CFX_FileBufferArchive();

+    virtual void			Clear();

+

+    FX_BOOL					AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover = FALSE);

+

+    FX_BOOL					AttachFile(FX_LPCWSTR filename);

+

+    FX_BOOL					AttachFile(FX_LPCSTR filename);

+private:

+

+    virtual FX_BOOL			DoWork(const void* pBuf, size_t size);

+

+    IFX_StreamWrite			*m_pFile;

+

+    FX_BOOL					m_bTakeover;

+};

+struct CFX_CharMap {

+

+    static CFX_CharMap*		GetDefaultMapper(FX_INT32 codepage = 0);

+

+

+    CFX_WideString	(*m_GetWideString)(CFX_CharMap* pMap, const CFX_ByteString& bstr);

+

+    CFX_ByteString	(*m_GetByteString)(CFX_CharMap* pMap, const CFX_WideString& wstr);

+

+    FX_INT32		(*m_GetCodePage)();

+};

+class CFX_UTF8Decoder

+{

+public:

+

+    CFX_UTF8Decoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator)

+    {

+        m_PendingBytes = 0;

+    }

+

+    void			Clear();

+

+    void			Input(FX_BYTE byte);

+

+    void			AppendChar(FX_DWORD ch);

+

+    void			ClearStatus()

+    {

+        m_PendingBytes = 0;

+    }

+

+    CFX_WideStringC	GetResult() const

+    {

+        return m_Buffer.GetWideString();

+    }

+    void			GetResult(CFX_WideStringL &result) const

+    {

+        m_Buffer.GetWideStringL(result);

+    }

+protected:

+

+    int				m_PendingBytes;

+

+    FX_DWORD		m_PendingChar;

+

+    CFX_WideTextBuf	m_Buffer;

+};

+class CFX_UTF8Encoder

+{

+public:

+

+    CFX_UTF8Encoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator)

+    {

+        m_UTF16First = 0;

+    }

+

+    void			Input(FX_WCHAR unicode);

+

+    void			AppendStr(FX_BSTR str)

+    {

+        m_UTF16First = 0;

+        m_Buffer << str;

+    }

+

+    CFX_ByteStringC	GetResult() const

+    {

+        return m_Buffer.GetByteString();

+    }

+    void			GetResult(CFX_ByteStringL &result) const

+    {

+        m_Buffer.GetByteStringL(result);

+    }

+protected:

+

+    CFX_ByteTextBuf	m_Buffer;

+

+    FX_DWORD		m_UTF16First;

+};

+CFX_ByteString FX_UrlEncode(const CFX_WideString& wsUrl);

+CFX_WideString FX_UrlDecode(const CFX_ByteString& bsUrl);

+CFX_ByteString FX_EncodeURI(const CFX_WideString& wsURI);

+CFX_WideString FX_DecodeURI(const CFX_ByteString& bsURI);

+class CFX_BasicArray : public CFX_Object

+{

+public:

+

+    IFX_Allocator*	m_pAllocator;

+protected:

+

+    CFX_BasicArray(int unit_size, IFX_Allocator* pAllocator = NULL);

+

+    ~CFX_BasicArray();

+

+    FX_BOOL			SetSize(int nNewSize, int nGrowBy);

+

+    FX_BOOL			Append(const CFX_BasicArray& src);

+

+    FX_BOOL			Copy(const CFX_BasicArray& src);

+

+    FX_LPBYTE		InsertSpaceAt(int nIndex, int nCount);

+

+    FX_BOOL			RemoveAt(int nIndex, int nCount);

+

+    FX_BOOL			InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);

+

+    const void*		GetDataPtr(int index) const;

+protected:

+

+    FX_LPBYTE		m_pData;

+

+    int				m_nSize;

+

+    int				m_nMaxSize;

+

+    int				m_nGrowBy;

+

+    int				m_nUnitSize;

+};

+template<class TYPE>

+class CFX_ArrayTemplate : public CFX_BasicArray

+{

+public:

+

+    CFX_ArrayTemplate(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(TYPE), pAllocator) {}

+

+    int			GetSize() const

+    {

+        return m_nSize;

+    }

+

+    int			GetUpperBound() const

+    {

+        return m_nSize - 1;

+    }

+

+    FX_BOOL		SetSize(int nNewSize, int nGrowBy = -1)

+    {

+        return CFX_BasicArray::SetSize(nNewSize, nGrowBy);

+    }

+

+    void		RemoveAll()

+    {

+        SetSize(0, -1);

+    }

+

+    const TYPE	GetAt(int nIndex) const

+    {

+        if (nIndex < 0 || nIndex >= m_nSize) {

+            return (const TYPE&)(*(volatile const TYPE*)NULL);

+        }

+        return ((const TYPE*)m_pData)[nIndex];

+    }

+

+    FX_BOOL		SetAt(int nIndex, TYPE newElement)

+    {

+        if (nIndex < 0 || nIndex >= m_nSize) {

+            return FALSE;

+        }

+        ((TYPE*)m_pData)[nIndex] = newElement;

+        return TRUE;

+    }

+

+    TYPE&		ElementAt(int nIndex)

+    {

+        if (nIndex < 0 || nIndex >= m_nSize) {

+            return *(TYPE*)NULL;

+        }

+        return ((TYPE*)m_pData)[nIndex];

+    }

+

+    const TYPE*	GetData() const

+    {

+        return (const TYPE*)m_pData;

+    }

+

+    TYPE*		GetData()

+    {

+        return (TYPE*)m_pData;

+    }

+

+    FX_BOOL		SetAtGrow(int nIndex, TYPE newElement)

+    {

+        if (nIndex < 0) {

+            return FALSE;

+        }

+        if (nIndex >= m_nSize)

+            if (!SetSize(nIndex + 1, -1)) {

+                return FALSE;

+            }

+        ((TYPE*)m_pData)[nIndex] = newElement;

+        return TRUE;

+    }

+

+    FX_BOOL		Add(TYPE newElement)

+    {

+        if (m_nSize < m_nMaxSize) {

+            m_nSize ++;

+        } else if (!SetSize(m_nSize + 1, -1)) {

+            return FALSE;

+        }

+        ((TYPE*)m_pData)[m_nSize - 1] = newElement;

+        return TRUE;

+    }

+

+    FX_BOOL		Append(const CFX_ArrayTemplate& src)

+    {

+        return CFX_BasicArray::Append(src);

+    }

+

+    FX_BOOL		Copy(const CFX_ArrayTemplate& src)

+    {

+        return CFX_BasicArray::Copy(src);

+    }

+

+    TYPE*		GetDataPtr(int index)

+    {

+        return (TYPE*)CFX_BasicArray::GetDataPtr(index);

+    }

+

+    TYPE*		AddSpace()

+    {

+        return (TYPE*)CFX_BasicArray::InsertSpaceAt(m_nSize, 1);

+    }

+

+    TYPE*		InsertSpaceAt(int nIndex, int nCount)

+    {

+        return (TYPE*)CFX_BasicArray::InsertSpaceAt(nIndex, nCount);

+    }

+

+    const TYPE	operator[](int nIndex) const

+    {

+        if (nIndex < 0 || nIndex >= m_nSize) {

+            *(volatile char*)0 = '\0';

+        }

+        return ((const TYPE*)m_pData)[nIndex];

+    }

+

+    TYPE&		operator[](int nIndex)

+    {

+        if (nIndex < 0 || nIndex >= m_nSize) {

+            *(volatile char*)0 = '\0';

+        }

+        return ((TYPE*)m_pData)[nIndex];

+    }

+

+    FX_BOOL		InsertAt(int nIndex, TYPE newElement, int nCount = 1)

+    {

+        if (!InsertSpaceAt(nIndex, nCount)) {

+            return FALSE;

+        }

+        while (nCount--) {

+            ((TYPE*)m_pData)[nIndex++] = newElement;

+        }

+        return TRUE;

+    }

+

+    FX_BOOL		RemoveAt(int nIndex, int nCount = 1)

+    {

+        return CFX_BasicArray::RemoveAt(nIndex, nCount);

+    }

+

+    FX_BOOL		InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray)

+    {

+        return CFX_BasicArray::InsertAt(nStartIndex, pNewArray);

+    }

+

+    int			Find(TYPE data, int iStart = 0) const

+    {

+        if (iStart < 0) {

+            return -1;

+        }

+        for (; iStart < (int)m_nSize; iStart ++)

+            if (((TYPE*)m_pData)[iStart] == data) {

+                return iStart;

+            }

+        return -1;

+    }

+};

+typedef CFX_ArrayTemplate<FX_BYTE>		CFX_ByteArray;

+typedef CFX_ArrayTemplate<FX_WORD>		CFX_WordArray;

+typedef CFX_ArrayTemplate<FX_DWORD>		CFX_DWordArray;

+typedef CFX_ArrayTemplate<void*>		CFX_PtrArray;

+typedef CFX_ArrayTemplate<FX_FILESIZE>	CFX_FileSizeArray;

+typedef CFX_ArrayTemplate<FX_FLOAT>		CFX_FloatArray;

+typedef CFX_ArrayTemplate<FX_INT32>		CFX_Int32Array;

+template <class ObjectClass>

+class CFX_ObjectArray : public CFX_BasicArray

+{

+public:

+

+    CFX_ObjectArray(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(ObjectClass), pAllocator) {}

+

+    ~CFX_ObjectArray()

+    {

+        RemoveAll();

+    }

+

+    void			Add(const ObjectClass& data)

+    {

+        new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);

+    }

+

+    ObjectClass&	Add()

+    {

+        return *(ObjectClass*) new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();

+    }

+

+    void*			AddSpace()

+    {

+        return InsertSpaceAt(m_nSize, 1);

+    }

+

+    FX_INT32		Append(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)

+    {

+        if (nCount == 0) {

+            return 0;

+        }

+        FX_INT32 nSize = src.GetSize();

+        if (!nSize) {

+            return 0;

+        }

+        FXSYS_assert(nStart > -1 && nStart < nSize);

+        if (nCount < 0) {

+            nCount = nSize;

+        }

+        if (nStart + nCount > nSize) {

+            nCount = nSize - nStart;

+        }

+        if (nCount < 1) {

+            return 0;

+        }

+        nSize = m_nSize;

+        InsertSpaceAt(m_nSize, nCount);

+        ObjectClass* pStartObj = (ObjectClass*)GetDataPtr(nSize);

+        nSize = nStart + nCount;

+        for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++) {

+            new ((void*)pStartObj) ObjectClass(src[i]);

+        }

+        return nCount;

+    }

+

+    FX_INT32		Copy(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)

+    {

+        if (nCount == 0) {

+            return 0;

+        }

+        FX_INT32 nSize = src.GetSize();

+        if (!nSize) {

+            return 0;

+        }

+        FXSYS_assert(nStart > -1 && nStart < nSize);

+        if (nCount < 0) {

+            nCount = nSize;

+        }

+        if (nStart + nCount > nSize) {

+            nCount = nSize - nStart;

+        }

+        if (nCount < 1) {

+            return 0;

+        }

+        RemoveAll();

+        SetSize(nCount, -1);

+        ObjectClass* pStartObj = (ObjectClass*)m_pData;

+        nSize = nStart + nCount;

+        for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++) {

+            new ((void*)pStartObj) ObjectClass(src[i]);

+        }

+        return nCount;

+    }

+

+    int				GetSize() const

+    {

+        return m_nSize;

+    }

+

+    ObjectClass&	operator[] (int index) const

+    {

+        FXSYS_assert(index < m_nSize);

+        return *(ObjectClass*)CFX_BasicArray::GetDataPtr(index);

+    }

+

+    ObjectClass*	GetDataPtr(int index)

+    {

+        return (ObjectClass*)CFX_BasicArray::GetDataPtr(index);

+    }

+

+    void			RemoveAt(int index)

+    {

+        FXSYS_assert(index < m_nSize);

+        ((ObjectClass*)GetDataPtr(index))->~ObjectClass();

+        CFX_BasicArray::RemoveAt(index, 1);

+    }

+

+    void			RemoveAll()

+    {

+        for (int i = 0; i < m_nSize; i ++) {

+            ((ObjectClass*)GetDataPtr(i))->~ObjectClass();

+        }

+        CFX_BasicArray::SetSize(0, -1);

+    }

+};

+typedef CFX_ObjectArray<CFX_ByteString> CFX_ByteStringArray;

+typedef CFX_ObjectArray<CFX_WideString> CFX_WideStringArray;

+class CFX_BaseSegmentedArray : public CFX_Object

+{

+public:

+

+    CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8, IFX_Allocator* pAllocator = NULL);

+

+    ~CFX_BaseSegmentedArray();

+

+    void	SetUnitSize(int unit_size, int segment_units, int index_size = 8);

+

+    void*	Add();

+

+    void*	GetAt(int index) const;

+

+    void	RemoveAll();

+

+    void	Delete(int index, int count = 1);

+

+    int		GetSize() const

+    {

+        return m_DataSize;

+    }

+

+    int		GetSegmentSize() const

+    {

+        return m_SegmentSize;

+    }

+

+    int		GetUnitSize() const

+    {

+        return m_UnitSize;

+    }

+

+    void*	Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;

+

+    IFX_Allocator*	m_pAllocator;

+private:

+

+    int				m_UnitSize;

+

+    short			m_SegmentSize;

+

+    FX_BYTE			m_IndexSize;

+

+    FX_BYTE			m_IndexDepth;

+

+    int				m_DataSize;

+

+    void*			m_pIndex;

+    void**	GetIndex(int seg_index) const;

+    void*	IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const;

+    void*	IterateSegment(FX_LPCBYTE pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;

+};

+template <class ElementType>

+class CFX_SegmentedArray : public CFX_BaseSegmentedArray

+{

+public:

+

+    CFX_SegmentedArray(int segment_units, int index_size = 8, IFX_Allocator* pAllocator = NULL)

+        : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size, pAllocator)

+    {}

+

+    void	Add(ElementType data)

+    {

+        *(ElementType*)CFX_BaseSegmentedArray::Add() = data;

+    }

+

+    ElementType& operator [] (int index)

+    {

+        return *(ElementType*)CFX_BaseSegmentedArray::GetAt(index);

+    }

+};

+template <class DataType, int FixedSize>

+class CFX_FixedBufGrow : public CFX_Object

+{

+public:

+    CFX_FixedBufGrow(IFX_Allocator* pAllocator = NULL)

+        : m_pAllocator(pAllocator)

+        , m_pData(NULL)

+    {}

+    CFX_FixedBufGrow(int data_size, IFX_Allocator* pAllocator = NULL)

+        : m_pAllocator(pAllocator)

+        , m_pData(NULL)

+    {

+        if (data_size > FixedSize) {

+            m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);

+        } else {

+            FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);

+        }

+    }

+    void SetDataSize(int data_size)

+    {

+        if (m_pData) {

+            FX_Allocator_Free(m_pAllocator, m_pData);

+        }

+        m_pData = NULL;

+        if (data_size > FixedSize) {

+            m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);

+        } else {

+            FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);

+        }

+    }

+    ~CFX_FixedBufGrow()

+    {

+        if (m_pData) {

+            FX_Allocator_Free(m_pAllocator, m_pData);

+        }

+    }

+    operator DataType*()

+    {

+        return m_pData ? m_pData : m_Data;

+    }

+private:

+    IFX_Allocator*	m_pAllocator;

+    DataType		m_Data[FixedSize];

+    DataType*		m_pData;

+};

+template <class DataType>

+class CFX_TempBuf

+{

+public:

+    CFX_TempBuf(int size, IFX_Allocator* pAllocator = NULL) : m_pAllocator(pAllocator)

+    {

+        m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, size);

+    }

+    ~CFX_TempBuf()

+    {

+        if (m_pData) {

+            FX_Allocator_Free(m_pAllocator, m_pData);

+        }

+    }

+    DataType&	operator[](int i)

+    {

+        FXSYS_assert(m_pData != NULL);

+        return m_pData[i];

+    }

+    operator DataType*()

+    {

+        return m_pData;

+    }

+private:

+    IFX_Allocator*	m_pAllocator;

+    DataType*		m_pData;

+};

+class CFX_MapPtrToPtr : public CFX_Object

+{

+protected:

+

+    struct CAssoc {

+

+        CAssoc* pNext;

+

+        void* key;

+

+        void* value;

+    };

+public:

+

+    CFX_MapPtrToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);

+

+    ~CFX_MapPtrToPtr();

+

+    int GetCount() const

+    {

+        return m_nCount;

+    }

+

+    FX_BOOL IsEmpty() const

+    {

+        return m_nCount == 0;

+    }

+

+    FX_BOOL Lookup(void* key, void*& rValue) const;

+

+    void* GetValueAt(void* key) const;

+

+    void*& operator[](void* key);

+

+    void SetAt(void* key, void* newValue)

+    {

+        (*this)[key] = newValue;

+    }

+

+    FX_BOOL RemoveKey(void* key);

+

+    void RemoveAll();

+

+    FX_POSITION GetStartPosition() const

+    {

+        return (m_nCount == 0) ? NULL : (FX_POSITION) - 1;

+    }

+

+    void GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void*& rValue) const;

+

+    FX_DWORD GetHashTableSize() const

+    {

+        return m_nHashTableSize;

+    }

+

+    void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);

+protected:

+

+    IFX_Allocator*	m_pAllocator;

+

+    CAssoc** m_pHashTable;

+

+    FX_DWORD m_nHashTableSize;

+

+    int m_nCount;

+

+    CAssoc* m_pFreeList;

+

+    struct CFX_Plex* m_pBlocks;

+

+    int m_nBlockSize;

+

+    FX_DWORD HashKey(void* key) const;

+

+    CAssoc* NewAssoc();

+

+    void FreeAssoc(CAssoc* pAssoc);

+

+    CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;

+};

+template <class KeyType, class ValueType>

+class CFX_MapPtrTemplate : public CFX_MapPtrToPtr

+{

+public:

+

+    CFX_MapPtrTemplate(IFX_Allocator* pAllocator = NULL) : CFX_MapPtrToPtr(10, pAllocator) {}

+

+    FX_BOOL	Lookup(KeyType key, ValueType& rValue) const

+    {

+        FX_LPVOID pValue = NULL;

+        if (!CFX_MapPtrToPtr::Lookup((void*)(FX_UINTPTR)key, pValue)) {

+            return FALSE;

+        }

+        rValue = (ValueType)(FX_UINTPTR)pValue;

+        return TRUE;

+    }

+

+    ValueType& operator[](KeyType key)

+    {

+        return (ValueType&)CFX_MapPtrToPtr::operator []((void*)(FX_UINTPTR)key);

+    }

+

+    void SetAt(KeyType key, ValueType newValue)

+    {

+        CFX_MapPtrToPtr::SetAt((void*)(FX_UINTPTR)key, (void*)(FX_UINTPTR)newValue);

+    }

+

+    FX_BOOL	RemoveKey(KeyType key)

+    {

+        return CFX_MapPtrToPtr::RemoveKey((void*)(FX_UINTPTR)key);

+    }

+

+    void GetNextAssoc(FX_POSITION& rNextPosition, KeyType& rKey, ValueType& rValue) const

+    {

+        void* pKey = NULL;

+        void* pValue = NULL;

+        CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);

+        rKey = (KeyType)(FX_UINTPTR)pKey;

+        rValue = (ValueType)(FX_UINTPTR)pValue;

+    }

+};

+class CFX_CMapDWordToDWord : public CFX_Object

+{

+public:

+

+    CFX_CMapDWordToDWord(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) {}

+

+    FX_BOOL			Lookup(FX_DWORD key, FX_DWORD& value) const;

+

+    void			SetAt(FX_DWORD key, FX_DWORD value);

+

+    void			EstimateSize(FX_DWORD size, FX_DWORD grow_by);

+

+    FX_POSITION		GetStartPosition() const;

+

+    void			GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;

+protected:

+

+    CFX_BinaryBuf	m_Buffer;

+};

+class CFX_MapByteStringToPtr : public CFX_Object

+{

+protected:

+

+    struct CAssoc {

+

+        CAssoc* pNext;

+

+        FX_DWORD nHashValue;

+

+        CFX_ByteString key;

+

+        void* value;

+    };

+public:

+

+    CFX_MapByteStringToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);

+

+    int GetCount() const

+    {

+        return m_nCount;

+    }

+

+    FX_BOOL IsEmpty() const

+    {

+        return m_nCount == 0;

+    }

+

+    FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;

+

+    void*& operator[](FX_BSTR key);

+

+    void SetAt(FX_BSTR key, void* newValue)

+    {

+        (*this)[key] = newValue;

+    }

+

+    FX_BOOL RemoveKey(FX_BSTR key);

+

+    void RemoveAll();

+

+    FX_POSITION GetStartPosition() const

+    {

+        return (m_nCount == 0) ? NULL : (FX_POSITION) - 1;

+    }

+

+    void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;

+

+    FX_LPVOID		GetNextValue(FX_POSITION& rNextPosition) const;

+

+    FX_DWORD GetHashTableSize() const

+    {

+        return m_nHashTableSize;

+    }

+

+    void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);

+

+    FX_DWORD HashKey(FX_BSTR key) const;

+protected:

+

+    IFX_Allocator*	m_pAllocator;

+

+    CAssoc** m_pHashTable;

+

+    FX_DWORD m_nHashTableSize;

+

+    int m_nCount;

+

+    CAssoc* m_pFreeList;

+

+    struct CFX_Plex* m_pBlocks;

+

+    int m_nBlockSize;

+

+    CAssoc* NewAssoc();

+

+    void FreeAssoc(CAssoc* pAssoc);

+

+    CAssoc* GetAssocAt(FX_BSTR key, FX_DWORD& hash) const;

+public:

+

+    ~CFX_MapByteStringToPtr();

+};

+class CFX_CMapByteStringToPtr : public CFX_Object

+{

+public:

+

+    CFX_CMapByteStringToPtr(IFX_Allocator* pAllocator = NULL);

+

+    ~CFX_CMapByteStringToPtr();

+

+    void			RemoveAll();

+

+    FX_POSITION		GetStartPosition() const;

+

+    void			GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;

+

+    FX_LPVOID		GetNextValue(FX_POSITION& rNextPosition) const;

+

+    FX_BOOL			Lookup(FX_BSTR key, void*& rValue) const;

+

+    void			SetAt(FX_BSTR key, void* value);

+

+    void			RemoveKey(FX_BSTR key);

+

+    int				GetCount() const;

+

+    void			AddValue(FX_BSTR key, void* pValue);

+private:

+

+    CFX_BaseSegmentedArray			m_Buffer;

+};

+class CFX_PtrList : public CFX_Object

+{

+protected:

+

+    struct CNode {

+

+        CNode* pNext;

+

+        CNode* pPrev;

+

+        void* data;

+    };

+public:

+

+    CFX_PtrList(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);

+

+    FX_POSITION GetHeadPosition() const

+    {

+        return (FX_POSITION)m_pNodeHead;

+    }

+

+    FX_POSITION GetTailPosition() const

+    {

+        return (FX_POSITION)m_pNodeTail;

+    }

+

+    void*	GetNext(FX_POSITION& rPosition) const

+    {

+        CNode* pNode = (CNode*) rPosition;

+        rPosition = (FX_POSITION) pNode->pNext;

+        return pNode->data;

+    }

+

+    void*	GetPrev(FX_POSITION& rPosition) const

+    {

+        CNode* pNode = (CNode*) rPosition;

+        rPosition = (FX_POSITION) pNode->pPrev;

+        return pNode->data;

+    }

+

+    FX_POSITION	GetNextPosition(FX_POSITION pos) const

+    {

+        return ((CNode*)pos)->pNext;

+    }

+

+    FX_POSITION	GetPrevPosition(FX_POSITION pos) const

+    {

+        return ((CNode*)pos)->pPrev;

+    }

+

+    void*	GetAt(FX_POSITION rPosition) const

+    {

+        CNode* pNode = (CNode*) rPosition;

+        return pNode->data;

+    }

+

+    int		GetCount() const

+    {

+        return m_nCount;

+    }

+

+    FX_POSITION	AddTail(void* newElement);

+

+    FX_POSITION AddHead(void* newElement);

+

+    void	SetAt(FX_POSITION pos, void* newElement)

+    {

+        CNode* pNode = (CNode*) pos;

+        pNode->data = newElement;

+    }

+

+    FX_POSITION InsertAfter(FX_POSITION pos, void* newElement);

+

+    FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL ) const;

+

+    FX_POSITION FindIndex(int index) const;

+

+    void	RemoveAt(FX_POSITION pos);

+

+    void	RemoveAll();

+protected:

+

+    IFX_Allocator*	m_pAllocator;

+

+    CNode* m_pNodeHead;

+

+    CNode* m_pNodeTail;

+

+    int m_nCount;

+

+    CNode* m_pNodeFree;

+

+    struct CFX_Plex* m_pBlocks;

+

+    int m_nBlockSize;

+

+    CNode* NewNode(CNode* pPrev, CNode* pNext);

+

+    void FreeNode(CNode* pNode);

+public:

+

+    ~CFX_PtrList();

+};

+typedef void (*PD_CALLBACK_FREEDATA)(FX_LPVOID pData);

+struct FX_PRIVATEDATA {

+

+    void					FreeData();

+

+    FX_LPVOID				m_pModuleId;

+

+    FX_LPVOID				m_pData;

+

+    PD_CALLBACK_FREEDATA	m_pCallback;

+

+    FX_BOOL					m_bSelfDestruct;

+};

+class CFX_PrivateData

+{

+public:

+

+    CFX_PrivateData(IFX_Allocator* pAllocator = NULL) : m_DataList(pAllocator) {}

+

+    ~CFX_PrivateData();

+

+    void					ClearAll();

+

+    void					SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback);

+

+    void					SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject* pObj);

+

+    FX_LPVOID				GetPrivateData(FX_LPVOID module_id);

+

+    FX_BOOL					LookupPrivateData(FX_LPVOID module_id, FX_LPVOID &pData) const

+    {

+        if (!module_id) {

+            return FALSE;

+        }

+        FX_DWORD nCount = m_DataList.GetSize();

+        for (FX_DWORD n = 0; n < nCount; n ++) {

+            if (m_DataList[n].m_pModuleId == module_id) {

+                pData = m_DataList[n].m_pData;

+                return TRUE;

+            }

+        }

+        return FALSE;

+    }

+

+    FX_BOOL					RemovePrivateData(FX_LPVOID module_id);

+protected:

+

+    CFX_ArrayTemplate<FX_PRIVATEDATA>	m_DataList;

+

+    void					AddData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct);

+};

+class CFX_BitStream : public CFX_Object

+{

+public:

+

+    void				Init(FX_LPCBYTE pData, FX_DWORD dwSize);

+

+

+    FX_DWORD			GetBits(FX_DWORD nBits);

+

+    void				ByteAlign();

+

+    FX_BOOL				IsEOF()

+    {

+        return m_BitPos >= m_BitSize;

+    }

+

+    void				SkipBits(FX_DWORD nBits)

+    {

+        m_BitPos += nBits;

+    }

+

+    void				Rewind()

+    {

+        m_BitPos = 0;

+    }

+protected:

+

+    FX_DWORD			m_BitPos;

+

+    FX_DWORD			m_BitSize;

+

+    FX_LPCBYTE			m_pData;

+};

+template <class ObjClass> class CFX_CountRef : public CFX_Object

+{

+public:

+

+    typedef CFX_CountRef<ObjClass> Ref;

+

+    class CountedObj : public ObjClass

+    {

+    public:

+

+        CountedObj() {}

+

+        CountedObj(const CountedObj& src) : ObjClass(src) {}

+

+        int			m_RefCount;

+    };

+

+    CFX_CountRef()

+    {

+        m_pObject = NULL;

+    }

+

+    CFX_CountRef(const Ref& ref)

+    {

+        m_pObject = ref.m_pObject;

+        if (m_pObject) {

+            m_pObject->m_RefCount ++;

+        }

+    }

+

+    ~CFX_CountRef()

+    {

+        if (!m_pObject) {

+            return;

+        }

+        m_pObject->m_RefCount --;

+        if (m_pObject->m_RefCount <= 0) {

+            delete m_pObject;

+        }

+    }

+

+    ObjClass*			New()

+    {

+        if (m_pObject) {

+            m_pObject->m_RefCount --;

+            if (m_pObject->m_RefCount <= 0) {

+                delete m_pObject;

+            }

+            m_pObject = NULL;

+        }

+        m_pObject = FX_NEW CountedObj;

+        if (!m_pObject) {

+            return NULL;

+        }

+        m_pObject->m_RefCount = 1;

+        return m_pObject;

+    }

+

+    void				operator = (const Ref& ref)

+    {

+        if (ref.m_pObject) {

+            ref.m_pObject->m_RefCount ++;

+        }

+        if (m_pObject) {

+            m_pObject->m_RefCount --;

+            if (m_pObject->m_RefCount <= 0) {

+                delete m_pObject;

+            }

+        }

+        m_pObject = ref.m_pObject;

+    }

+

+    void				operator = (void* p)

+    {

+        FXSYS_assert(p == 0);

+        if (m_pObject == NULL) {

+            return;

+        }

+        m_pObject->m_RefCount --;

+        if (m_pObject->m_RefCount <= 0) {

+            delete m_pObject;

+        }

+        m_pObject = NULL;

+    }

+

+    const ObjClass*		GetObject() const

+    {

+        return m_pObject;

+    }

+

+    operator			const ObjClass*() const

+    {

+        return m_pObject;

+    }

+

+    FX_BOOL				IsNull() const

+    {

+        return m_pObject == NULL;

+    }

+

+    FX_BOOL				NotNull() const

+    {

+        return m_pObject != NULL;

+    }

+

+    ObjClass*			GetModify()

+    {

+        if (m_pObject == NULL) {

+            m_pObject = FX_NEW CountedObj;

+            if (m_pObject) {

+                m_pObject->m_RefCount = 1;

+            }

+        } else if (m_pObject->m_RefCount > 1) {

+            m_pObject->m_RefCount --;

+            CountedObj* pOldObject = m_pObject;

+            m_pObject = NULL;

+            m_pObject = FX_NEW CountedObj(*pOldObject);

+            if (m_pObject) {

+                m_pObject->m_RefCount = 1;

+            }

+        }

+        return m_pObject;

+    }

+

+    void				SetNull()

+    {

+        if (m_pObject == NULL) {

+            return;

+        }

+        m_pObject->m_RefCount --;

+        if (m_pObject->m_RefCount <= 0) {

+            delete m_pObject;

+        }

+        m_pObject = NULL;

+    }

+

+    FX_BOOL				operator == (const Ref& ref) const

+    {

+        return m_pObject == ref.m_pObject;

+    }

+protected:

+

+    CountedObj*			m_pObject;

+};

+class IFX_Pause

+{

+public:

+

+    virtual FX_BOOL	NeedToPauseNow() = 0;

+};

+class CFX_DataFilter : public CFX_Object

+{

+public:

+

+    virtual ~CFX_DataFilter();

+

+    void			SetDestFilter(CFX_DataFilter* pFilter);

+

+    FX_BOOL			IsEOF() const

+    {

+        return m_bEOF;

+    }

+

+    FX_DWORD		GetSrcPos()

+    {

+        return m_SrcPos;

+    }

+

+    void			FilterIn(FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);

+

+    void			FilterFinish(CFX_BinaryBuf& dest_buf);

+protected:

+

+    CFX_DataFilter();

+    virtual void	v_FilterIn(FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf) = 0;

+    virtual void	v_FilterFinish(CFX_BinaryBuf& dest_buf) = 0;

+    void			ReportEOF(FX_DWORD left_input);

+

+    FX_BOOL			m_bEOF;

+

+    FX_DWORD		m_SrcPos;

+

+    CFX_DataFilter*	m_pDestFilter;

+};

+template <class T>

+class CFX_SmartPointer

+{

+public:

+    CFX_SmartPointer(T *pObj) : m_pObj(pObj) {}

+    ~CFX_SmartPointer()

+    {

+        m_pObj->Release();

+    }

+    operator T*(void)

+    {

+        return m_pObj;

+    }

+    T&		operator *(void)

+    {

+        return *m_pObj;

+    }

+    T*		operator ->(void)

+    {

+        return m_pObj;

+    }

+protected:

+    T *m_pObj;

+};

+#define FX_DATALIST_LENGTH	1024

+template<size_t unit>

+class CFX_SortListArray : public CFX_Object

+{

+protected:

+

+    struct DataList {

+

+        FX_INT32	start;

+

+        FX_INT32	count;

+        FX_LPBYTE	data;

+    };

+public:

+

+    CFX_SortListArray(IFX_Allocator* pAllocator = NULL) : m_CurList(0), m_DataLists(pAllocator) {}

+

+    ~CFX_SortListArray()

+    {

+        Clear();

+    }

+

+

+    void			Clear()

+    {

+        IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;

+        for (FX_INT32 i = m_DataLists.GetUpperBound(); i >= 0; i--) {

+            DataList list = m_DataLists.ElementAt(i);

+            if (list.data) {

+                FX_Allocator_Free(pAllocator, list.data);

+            }

+        }

+        m_DataLists.RemoveAll();

+        m_CurList = 0;

+    }

+

+    void			Append(FX_INT32 nStart, FX_INT32 nCount)

+    {

+        if (nStart < 0) {

+            return;

+        }

+        IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;

+        while (nCount > 0) {

+            FX_INT32 temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);

+            DataList list;

+            list.data = FX_Allocator_Alloc(pAllocator, FX_BYTE, temp_count * unit);

+            if (!list.data) {

+                break;

+            }

+            FXSYS_memset32(list.data, 0, temp_count * unit);

+            list.start = nStart;

+            list.count = temp_count;

+            Append(list);

+            nCount -= temp_count;

+            nStart += temp_count;

+        }

+    }

+

+    FX_LPBYTE		GetAt(FX_INT32 nIndex)

+    {

+        if (nIndex < 0) {

+            return NULL;

+        }

+        if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) {

+            return NULL;

+        }

+        DataList *pCurList = m_DataLists.GetDataPtr(m_CurList);

+        if (!pCurList || nIndex < pCurList->start || nIndex >= pCurList->start + pCurList->count) {

+            pCurList = NULL;

+            FX_INT32 iStart = 0;

+            FX_INT32 iEnd = m_DataLists.GetUpperBound();

+            FX_INT32 iMid = 0;

+            while (iStart <= iEnd) {

+                iMid = (iStart + iEnd) / 2;

+                DataList* list = m_DataLists.GetDataPtr(iMid);

+                if (nIndex < list->start) {

+                    iEnd = iMid - 1;

+                } else if (nIndex >= list->start + list->count) {

+                    iStart = iMid + 1;

+                } else {

+                    pCurList = list;

+                    m_CurList = iMid;

+                    break;

+                }

+            }

+        }

+        return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;

+    }

+protected:

+    void			Append(const DataList& list)

+    {

+        FX_INT32 iStart = 0;

+        FX_INT32 iEnd = m_DataLists.GetUpperBound();

+        FX_INT32 iFind = 0;

+        while (iStart <= iEnd) {

+            FX_INT32 iMid = (iStart + iEnd) / 2;

+            DataList* cur_list = m_DataLists.GetDataPtr(iMid);

+            if (list.start < cur_list->start + cur_list->count) {

+                iEnd = iMid - 1;

+            } else {

+                if (iMid == iEnd) {

+                    iFind = iMid + 1;

+                    break;

+                }

+                DataList* next_list = m_DataLists.GetDataPtr(iMid + 1);

+                if (list.start < next_list->start) {

+                    iFind = iMid + 1;

+                    break;

+                } else {

+                    iStart = iMid + 1;

+                }

+            }

+        }

+        m_DataLists.InsertAt(iFind, list);

+    }

+    FX_INT32		m_CurList;

+    CFX_ArrayTemplate<DataList>	m_DataLists;

+};

+template<typename T1, typename T2>

+class CFX_ListArrayTemplate : public CFX_Object

+{

+public:

+

+    void			Clear()

+    {

+        m_Data.Clear();

+    }

+

+    void			Add(FX_INT32 nStart, FX_INT32 nCount)

+    {

+        m_Data.Append(nStart, nCount);

+    }

+

+    T2&				operator [] (FX_INT32 nIndex)

+    {

+        FX_LPBYTE data = m_Data.GetAt(nIndex);

+        FXSYS_assert(data != NULL);

+        return (T2&)(*(volatile T2*)data);

+    }

+

+    T2*				GetPtrAt(FX_INT32 nIndex)

+    {

+        return (T2*)m_Data.GetAt(nIndex);

+    }

+protected:

+    T1			m_Data;

+};

+typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_FILESIZE)>, FX_FILESIZE>	CFX_FileSizeListArray;

+typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_DWORD)>, FX_DWORD>		CFX_DWordListArray;

+typedef enum {

+    Ready,

+    ToBeContinued,

+    Found,

+    NotFound,

+    Failed,

+    Done

+} FX_ProgressiveStatus;

+#define ProgressiveStatus	FX_ProgressiveStatus

+#define FX_NAMESPACE_DECLARE(namespace, type)       namespace::type

+#endif