fx_memory.h

浏览该文件的文档.

//<<<+++OPENSOURCE
//<<<+++OPENSOURCE_LICENSE
//<<<+++OPENSOURCE_BEGIN LIC==FOXIT||LIC==GOOGLE

/*
 *
 * FPDFAPI 可能使用与应用程序不同的堆（在 FPDFAPI 的 DLL 版本情况下），
 * 因此，为了在 API 和应用程序之间交换指针，应用程序应使用以下
 * 内存分配和释放函数。
 *
 *
 * FOXIT API 中有两层内存管理器：
 *
 *  1. 系统级内存管理器。此级别依赖于系统。
 *    API 提供了一个默认的系统内存管理器（使用 CRT malloc/free 函数），
 *    但应用程序可以实现自己的管理器以适应不同的系统环境。
 *
 *  2. Foxit 内存管理器。此级别与系统无关，但依赖于系统级管理器。
 *    API 提供了一个默认的 Foxit 内存管理器，它依赖于默认的系统管理器。
 *    应用程序无法自定义 Foxit 内存管理器，但它们可以创建不同的
 *    Foxit 内存管理器实例，依赖于不同的底层系统管理器
 *    （例如，每个系统管理器可能使用不同的堆，那么，不同的 Foxit 管理器
 *    将能够使用单独的堆。）
 *
 *
 *  Foxit 内存管理器还提供子堆功能，用于将对象聚合在一起
 *  以避免内存碎片。
 */

//<<<+++OPENSOURCE_MUST_BEGIN
#ifndef _FX_MEMORY_H_
#define _FX_MEMORY_H_

#ifndef _FX_SYSTEM_H_
  #include "fx_system.h"
#endif
//<<<+++OPENSOURCE_MUST_END

#define FXMEM_NONLEAVE      1

#define FXMEM_MOVABLE      2

#define FXMEM_DISCARDABLE    4

// 基础内存例程
#ifdef __cplusplus
extern "C" {
#endif

typedef struct _FXMEM_SystemMgr {
  void* (*Alloc)(struct _FXMEM_SystemMgr* pMgr, size_t size, int flags);
  void* (*AllocDebug)(struct _FXMEM_SystemMgr* pMgr, size_t size, int flags, FX_LPCSTR file, int line);
  void* (*Realloc)(struct _FXMEM_SystemMgr* pMgr, void* pointer, size_t size, int flags);
  void* (*ReallocDebug)(struct _FXMEM_SystemMgr* pMgr, void* pointer, size_t size, int flags, FX_LPCSTR file, int line);
  void* (*Lock)(struct _FXMEM_SystemMgr* pMgr, void* handle);
  void  (*Unlock)(struct _FXMEM_SystemMgr* pMgr, void* handle);
  void  (*Free)(struct _FXMEM_SystemMgr* pMgr, void* pointer, int flags);
  void  (*Purge)(struct _FXMEM_SystemMgr* pMgr);
  void  (*CollectAll)(struct _FXMEM_SystemMgr* pMgr);

  void* user;
} FXMEM_SystemMgr;

FX_DEFINEHANDLE(FXMEM_FoxitMgr)


FXMEM_FoxitMgr*  FXMEM_CreateFoxitMgr(FXMEM_SystemMgr* pSystemMgr);

FXMEM_FoxitMgr* FXMEM_CreatePyMgr();

int FXMEM_SetPyConfig(size_t lowByteRange, size_t highByteRange);

typedef struct _FXMEM_SystemMgr2
{
  FX_BOOL  (*More)(struct _FXMEM_SystemMgr2* pMgr, size_t alloc_size, void** new_memory, size_t* new_size);
  void  (*Free)(struct _FXMEM_SystemMgr2* pMgr, void* memory);
} FXMEM_SystemMgr2;

FXMEM_FoxitMgr*  FXMEM_CreateFixedMgr(void* pMemory, size_t size, FXMEM_SystemMgr2* pExtender);

FXMEM_FoxitMgr* FXMEM_CreateMemoryMgr(size_t size, FX_BOOL extensible);

size_t FXMEM_GetBlockSizeInFixedMgr(FXMEM_FoxitMgr* pFoxitMgr, void* ptr);

FXMEM_FoxitMgr* FXMEM_GetDefaultMgr();

void  FXMEM_SetDefaultMgr(FXMEM_FoxitMgr* pFoxitMgr);

void FXMEM_ResetSystemMgr();

void  FXMEM_DestroyFoxitMgr(FXMEM_FoxitMgr* pFoxitMgr);


void*  FXMEM_Alloc(FXMEM_FoxitMgr* pFoxitMgr, size_t size, int flags);
void*  FXMEM_AllocDebug(FXMEM_FoxitMgr* pFoxitMgr, size_t size, int flags, FX_LPCSTR file, int line);
void*  FXMEM_Realloc(FXMEM_FoxitMgr* pFoxitMgr, void* pointer, size_t new_size, int flags);
void*  FXMEM_ReallocDebug(FXMEM_FoxitMgr* pFoxitMgr, void* pointer, size_t new_size, int flags, FX_LPCSTR file, int line);
void  FXMEM_Free(FXMEM_FoxitMgr* pFoxitMgr, void* pointer, int flags);

void  FXMEM_CollectAll(FXMEM_FoxitMgr* pFoxitMgr);

void  FXMEM_PurgeMgr(FXMEM_FoxitMgr* pFoxitMgr);

void  FXMEM_ReportOOM(FXMEM_FoxitMgr* pFoxitMgr);

typedef struct {
  void  (*OnAlloc)(FXMEM_FoxitMgr* pMgr, void* p, size_t size, int flags);
  void  (*OnAllocDebug)(FXMEM_FoxitMgr* pMgr, void* p, size_t size, int flags, FX_LPCSTR file, int line);
  void  (*OnRealloc)(FXMEM_FoxitMgr* pMgr, void* old_p, void* new_p, size_t size, int flags);
  void  (*OnReallocDebug)(FXMEM_FoxitMgr* pMgr, void* old_p, void* new_p, size_t size, int flags, FX_LPCSTR file, int line);
  void  (*OnFree)(FXMEM_FoxitMgr* pMgr, void* p, int flags);
  void  (*OnTag)(FXMEM_FoxitMgr* pMgr, FX_LPCSTR tag);
} FXMEM_Debugger;

void  FXMEM_UseDebugger(FXMEM_FoxitMgr* pFoxitMgr, FXMEM_Debugger* pDebugger);

void  FXMEM_OutputDebugTag(FXMEM_FoxitMgr* pFoxitMgr, FX_LPCSTR tag);

typedef void (*FPDF_OOM_Handler)(FXMEM_FoxitMgr* pFoxitMgr, void* param);

void  FXMEM_SetOOMHandler(FXMEM_FoxitMgr* pFoxitMgr, FPDF_OOM_Handler pOOMReportFunc, void* param);


void*  FXMEM_DefaultAlloc(size_t byte_size, int flags);
void*  FXMEM_DefaultAlloc2(size_t units, size_t unit_size, int flags);
void*  FXMEM_DefaultAllocDebug(size_t size, int flags, FX_LPCSTR file, int line);
void*  FXMEM_DefaultAllocDebug2(size_t units, size_t unit_size, int flags, FX_LPCSTR file, int line);
void*  FXMEM_DefaultRealloc(void* pointer, size_t new_size, int flags);
void*  FXMEM_DefaultRealloc2(void* pointer, size_t units, size_t unit_size, int flags);
void*  FXMEM_DefaultReallocDebug(void* pointer, size_t new_size, int flags, FX_LPCSTR file, int line);
void*  FXMEM_DefaultReallocDebug2(void* pointer, size_t units, size_t unit_size, int flags, FX_LPCSTR file, int line);
void  FXMEM_DefaultFree(void* pointer, int flags);

/* FPDFAPI应用程序应该为非类数据类型使用FX_Alloc宏 */
#ifdef _DEBUG
  #define FX_Alloc(type, size) (type*)FXMEM_DefaultAllocDebug2(size, sizeof(type), 0, __FILE__, __LINE__)
  #define FX_Realloc(type, ptr, new_size) (type*)FXMEM_DefaultReallocDebug2(ptr, new_size, sizeof(type), 0, __FILE__, __LINE__)
#else

  #define FX_Alloc(type, size) (type*)FXMEM_DefaultAlloc2(size, sizeof(type), 0)

  #define FX_Realloc(type, ptr, size) (type*)FXMEM_DefaultRealloc2(ptr, size, sizeof(type), 0)
#endif

#ifdef _DEBUG
  #define FX_AllocNL(type, size) (type*)FXMEM_DefaultAllocDebug2(size, sizeof(type), FXMEM_NONLEAVE, __FILE__, __LINE__)
  #define FX_ReallocNL(type, ptr, new_size) (type*)FXMEM_DefaultReallocDebug2(ptr, new_size, sizeof(type), FXMEM_NONLEAVE, __FILE__, __LINE__)
#else

  #define FX_AllocNL(type, size) (type*)FXMEM_DefaultAlloc2(size, sizeof(type), FXMEM_NONLEAVE)

  #define FX_ReallocNL(type, ptr, size) (type*)FXMEM_DefaultRealloc2(ptr, size, sizeof(type), FXMEM_NONLEAVE)
#endif

#define FX_Free(pointer) FXMEM_DefaultFree(pointer, 0)

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus

#include <memory>
#include <algorithm>
#include <utility>

#if __cplusplus >= 201103L
#define FX_EQDELETE = delete
#define FX_NOEXCEPT noexcept
#define FX_EXPLICIT_OPERATOR explicit
#else
#define FX_EQDELETE //= delete
#define FX_NOEXCEPT //noexcept
#define FX_EXPLICIT_OPERATOR //explicit
#endif
// 一个可以持有拥有或非拥有引用的模板，并进行适当的清理。
// 可能是最恶劣的反模式，但由于避免复制对象或数据的需要，
// 在整个代码库中经常出现。
template <typename T, typename D = std::default_delete<T>>
class CFX_MaybeOwned {
 public:
  CFX_MaybeOwned() : m_pObj(nullptr) {}
  explicit CFX_MaybeOwned(T* ptr) : m_pObj(ptr) {}
  explicit CFX_MaybeOwned(std::unique_ptr<T, D> ptr)
    : m_pOwnedObj(std::move(ptr)), m_pObj(m_pOwnedObj.get()) {}

  CFX_MaybeOwned(CFX_MaybeOwned&& that) FX_NOEXCEPT
    : m_pOwnedObj(that.m_pOwnedObj.release()), m_pObj(that.m_pObj) {
    that.m_pObj = nullptr;
  }

  void Reset(std::unique_ptr<T, D> ptr) {
    m_pOwnedObj = std::move(ptr);
    m_pObj = m_pOwnedObj.get();
  }
  void Reset(T* ptr = nullptr) {
    m_pOwnedObj.reset();
    m_pObj = ptr;
  }

  bool IsOwned() const { return !!m_pOwnedObj; }
  T* Get() const { return m_pObj; }
  std::unique_ptr<T, D> Release() {
    ASSERT(IsOwned());
    return std::move(m_pOwnedObj);
  }

  CFX_MaybeOwned& operator=(CFX_MaybeOwned&& that) {
    m_pOwnedObj = std::move(that.m_pOwnedObj);
    m_pObj = that.m_pObj;
    that.m_pObj = nullptr;
    return *this;
  }
  CFX_MaybeOwned& operator=(T* ptr) {
    Reset(ptr);
    return *this;
  }
  CFX_MaybeOwned& operator=(std::unique_ptr<T, D> ptr) {
    Reset(std::move(ptr));
    return *this;
  }

  bool operator==(const CFX_MaybeOwned& that) const {
    return Get() == that.Get();
  }
  bool operator==(const std::unique_ptr<T, D>& ptr) const {
    return Get() == ptr.get();
  }
  bool operator==(T* ptr) const { return Get() == ptr; }

  bool operator!=(const CFX_MaybeOwned& that) const { return !(*this == that); }
  bool operator!=(const std::unique_ptr<T, D> ptr) const {
    return !(*this == ptr);
  }
  bool operator!=(T* ptr) const { return !(*this == ptr); }

  FX_EXPLICIT_OPERATOR operator bool() const { return !!m_pObj; }
  T& operator*() const { return *m_pObj; }
  T* operator->() const { return m_pObj; }
 private:
  CFX_MaybeOwned(const CFX_MaybeOwned& that) FX_EQDELETE;
  CFX_MaybeOwned& operator=(const CFX_MaybeOwned& that) FX_EQDELETE;

 private:
  std::unique_ptr<T, D> m_pOwnedObj;
  T* m_pObj;
};

// 与std::unique_ptr一起使用以FX_Free原始内存。
struct CFX_FreeDeleter {
  inline void operator()(void* ptr) const { FX_Free(ptr); }
};
class CFX_Object
{
 public:
  void*      operator new (size_t size, FX_LPCSTR file, int line);
#ifndef _FX_NO_EXCEPTION_

  void      operator delete (void* p, FX_LPCSTR file, int line);
#endif

  void*      operator new (size_t size);
  void      operator delete (void* p);

  void*      operator new[] (size_t size, FX_LPCSTR file, int line);
#ifndef _FX_NO_EXCEPTION_

  void      operator delete[] (void* p, FX_LPCSTR file, int line);
#endif

  void*      operator new[] (size_t size);
  void      operator delete[] (void* p);

  void*      operator new (size_t, void* buf) { return buf; }
#ifndef _FX_NO_EXCEPTION_

  void      operator delete (void*, void*) {}
#endif
 protected:
  ~CFX_Object() {}
};

#if (_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_) && !defined(__PLACEMENT_NEW_INLINE) && !defined(_MFC_VER) && !defined(_NEW)
  #define __PLACEMENT_NEW_INLINE

  inline void* operator new(size_t size, void* pos)
  {
    return pos;
  }

  inline void operator delete(void* ptr, void* pos)
  {
  }
#endif //__PLACEMENT_NEW_INLINE

#endif //__cplusplus

//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#ifdef __cplusplus

#if defined(_DEBUG)
  #define FX_NEW new(__FILE__, __LINE__)
#else

  #define FX_NEW new
#endif
//<<<+++OPENSOURCE_MUST_END

#ifndef _FPDFAPI_MINI_
  //<<<+++OPENSOURCE_BEGIN LIC==FOXIT
  #define FX_NEW_VECTOR(Pointer, Class, Count) Pointer = FX_NEW Class[Count]

  #define FX_DELETE_VECTOR(Pointer, Class, Count) delete[] Pointer
  //<<<+++OPENSOURCE_END
#else
  //<<<+++OPENSOURCE_BEGIN LIC==GOOGLE
  #define FX_NEW_VECTOR(Pointer, Class, Count) \
    { \
      Pointer = FX_Alloc(Class, Count); \
      if (Pointer) { \
        for (int i = 0; i < (Count); i ++) new (Pointer + i) Class; \
      } \
    }
  #define FX_DELETE_VECTOR(Pointer, Class, Count) \
    { \
      for (int i = 0; i < (Count); i ++) Pointer[i].~Class(); \
      FX_Free(Pointer); \
    }
  //<<<+++OPENSOURCE_END
#endif

//<<<+++OPENSOURCE_MUST_BEGIN
class CFX_DestructObject : public CFX_Object
{
 public:
  virtual ~CFX_DestructObject() {}
};
//<<<+++OPENSOURCE_MUST_END
#endif //__cplusplus

#ifdef __cplusplus
extern "C" {
#endif

typedef struct _IFX_Allocator
{
  void*  (*m_AllocDebug)(struct _IFX_Allocator* pAllocator, size_t size, FX_LPCSTR file, int line);
  void*  (*m_Alloc)(struct _IFX_Allocator* pAllocator, size_t size);
  void*  (*m_ReallocDebug)(struct _IFX_Allocator* pAllocator, void* p, size_t size, FX_LPCSTR file, int line);
  void*  (*m_Realloc)(struct _IFX_Allocator* pAllocator, void* p, size_t size);
  void  (*m_Free)(struct _IFX_Allocator* pAllocator, void* p);
} IFX_Allocator;

IFX_Allocator* FXMEM_GetDefAllocator();

#ifdef __cplusplus
}
#endif

#ifdef _DEBUG

  #define FX_Allocator_Alloc(fxAllocator, type, size) \
    ((fxAllocator) ? (type*)(fxAllocator)->m_AllocDebug((fxAllocator), (size) * sizeof(type), __FILE__, __LINE__) : (FX_Alloc(type, size)))

  #define FX_Allocator_Realloc(fxAllocator, type, ptr, new_size) \
    ((fxAllocator) ? (type*)(fxAllocator)->m_ReallocDebug((fxAllocator), (ptr), (new_size) * sizeof(type), __FILE__, __LINE__) : (FX_Realloc(type, ptr, new_size)))
#else

  #define FX_Allocator_Alloc(fxAllocator, type, size) \
    ((fxAllocator) ? (type*)(fxAllocator)->m_Alloc((fxAllocator), (size) * sizeof(type)) : (FX_Alloc(type, size)))

  #define FX_Allocator_Realloc(fxAllocator, type, ptr, new_size) \
    ((fxAllocator) ? (type*)(fxAllocator)->m_Realloc((fxAllocator), (ptr), (new_size) * sizeof(type)) : (FX_Realloc(type, ptr, new_size)))
#endif

#define FX_Allocator_Free(fxAllocator, ptr) \
    ((fxAllocator) ? (fxAllocator)->m_Free((fxAllocator), (ptr)) : (FX_Free(ptr)))
//<<<+++OPENSOURCE_MUST_END

#ifdef __cplusplus

inline void* operator new(size_t size, IFX_Allocator* fxAllocator)
{
  return (void*)FX_Allocator_Alloc(fxAllocator, FX_BYTE, size);
}

inline void operator delete(void* ptr, IFX_Allocator* fxAllocator)
{
  FX_Allocator_Free(fxAllocator, ptr);
}

#define FX_NewAtAllocator(fxAllocator) \
  ::new(static_cast<IFX_Allocator*>(fxAllocator))

#define FX_DeleteAtAllocator(pointer, fxAllocator, __class__) \
  do { (pointer)->~__class__(); ::operator delete(static_cast<void*>(pointer), static_cast<IFX_Allocator*>(fxAllocator)); } while(false)

class CFX_AllocObject
{
 public:
  void*      operator new (size_t size, IFX_Allocator* pAllocator, FX_LPCSTR file, int line);
#ifndef _FX_NO_EXCEPTION_

  void      operator delete (void* p, IFX_Allocator* pAllocator, FX_LPCSTR file, int line);
#endif

  void*      operator new (size_t size, IFX_Allocator* pAllocator);
  void      operator delete (void* p);
#ifndef _FX_NO_EXCEPTION_

  void      operator delete (void* p, IFX_Allocator* pAllocator);
#endif

  void*      operator new (size_t, void* buf) { return buf; }
#ifndef _FX_NO_EXCEPTION_

  void      operator delete (void*, void*) {}
#endif

  IFX_Allocator*  GetAllocator() const { return m_pAllocator; }

private:  /* 所有向量操作符都被禁用 */
  void*      operator new[] (size_t size, IFX_Allocator* pAllocator, FX_LPCSTR file, int line) { return operator new(size, pAllocator, file, line); }
#ifndef _FX_NO_EXCEPTION_

  void      operator delete[] (void* p, IFX_Allocator* pAllocator, FX_LPCSTR file, int line) {}
#endif

  void*      operator new[] (size_t size, IFX_Allocator* pAllocator) { return operator new(size, pAllocator); }
  void      operator delete[] (void* p) {}
#ifndef _FX_NO_EXCEPTION_

  void      operator delete[] (void* p, IFX_Allocator* pAllocator) {}
#endif

 protected:
  /*
   * 内存分配器。
   */
  IFX_Allocator*  m_pAllocator;
};

#if defined(_DEBUG)
  #define FX_NEWAT(pAllocator) new(pAllocator, __FILE__, __LINE__)
#else

  #define FX_NEWAT(pAllocator) new(pAllocator)
#endif

//并发控制

#if !defined(_FPDFAPI_MT_NONE_) && !defined(_FPDFAPI_MT_)
  // 我们在所有系统上默认启用多线程。然而，MT可以通过编译宏禁用
  #define _FPDFAPI_MT_
#endif

#ifdef _FPDFAPI_MT_

  class CFX_LockObject : public CFX_Object
  {
 public:
    CFX_LockObject() {FX_InitializeCriticalSection(&m_Lock);}
    ~CFX_LockObject() {FX_DeleteCriticalSection(&m_Lock);}

    FX_BOOL    TryLock()  {return FX_TryEnterCriticalSection(&m_Lock);}
    void    Lock()    {FX_EnterCriticalSection(&m_Lock);}
    void    Unlock()  {FX_LeaveCriticalSection(&m_Lock);}

 protected:
    /* 临界区。 */
    FX_CRITICAL_SECTION    m_Lock;
    friend class CFX_CSLock;
  };

  class CFX_CSLock
  {
 public:
    CFX_CSLock() : m_pCS(NULL) {}
    CFX_CSLock(FX_CRITICAL_SECTION* pCS) : m_pCS(pCS) {if (m_pCS) FX_EnterCriticalSection(m_pCS);}
    CFX_CSLock(CFX_LockObject* pObj) {m_pCS = &pObj->m_Lock; FX_EnterCriticalSection(m_pCS);}
    ~CFX_CSLock() {if (m_pCS) FX_LeaveCriticalSection(m_pCS);}

    FX_CRITICAL_SECTION*  m_pCS;
  };

  #define FXMT_CSLOCK_THIS          CFX_CSLock _fx_lock((CFX_LockObject*)this)

  #define FXMT_CSLOCK_OBJ(lock)        CFX_CSLock _fx_lock((CFX_LockObject*)lock)

  #define FXMT_CSLOCK_DEFINEOBJ(csLock, lock) CFX_CSLock csLock((CFX_LockObject*)lock)

  #define FXMT_LOCKOBJECT_DEFINE(lockObj)    CFX_LockObject lockObj

  #define FXMT_LOCKOBJECT_TRYLOCK(lockObj)  (lockObj)->TryLock()

  #define FXMT_LOCKOBJECT_TRYLOCK_IF(lockObj)  if ((lockObj)->TryLock())

  #define FXMT_LOCKOBJECT_LOCK(lockObj)    (lockObj)->Lock()

  #define FXMT_LOCKOBJECT_UNLOCK(lockObj)    (lockObj)->Unlock()
#else 
  class CFX_LockObject : public CFX_Object {};
  #define FXMT_CSLOCK_THIS
  #define FXMT_CSLOCK_OBJ(lock)
  #define FXMT_CSLOCK_DEFINEOBJ(csLock, lock)

  #define FXMT_LOCKOBJECT_DEFINE(lockObj)
  #define FXMT_LOCKOBJECT_TRYLOCK(lockObj)
  #define FXMT_LOCKOBJECT_TRYLOCK_IF(lockObj)  if (1)
  #define FXMT_LOCKOBJECT_LOCK(lockObj)
  #define FXMT_LOCKOBJECT_UNLOCK(lockObj)
#endif
//<<<+++OPENSOURCE_MUST_END

class CFX_GrowOnlyPool : public IFX_Allocator, public CFX_Object

{
 public:
  CFX_GrowOnlyPool(IFX_Allocator* pAllocator = NULL, size_t trunk_size = 16384);

  ~CFX_GrowOnlyPool();

  void  SetAllocator(IFX_Allocator* pAllocator);

  void  SetTrunkSize(size_t trunk_size) { m_TrunkSize = trunk_size; }

  void*  AllocDebug(size_t size, FX_LPCSTR file, int line) { return Alloc(size); }
  void*  Alloc(size_t size);
  void*  ReallocDebug(void* p, size_t new_size, FX_LPCSTR file, int line) { return NULL; }
  void*  Realloc(void* p, size_t new_size) { return NULL; }
  void Free(void* mem) {}

  void  FreeAll();

 private:
  /* Trunk大小。 */
  size_t  m_TrunkSize;
  /* 指向第一个trunk的指针。 */
  void*  m_pFirstTrunk;

  /* 内存分配器。 */
  IFX_Allocator*  m_pAllocator;
    /* 用于同步的临界区。 */
    FX_CRITICAL_SECTION  m_Lock;

};

// 用于分配内存的代理类。

template <class T> class AllocProxy : public CFX_Object {
 public:
  AllocProxy(size_t size) { buffer = (T *)FX_Alloc(T, size); }
  ~AllocProxy() { if (buffer) FX_Free(buffer); }
  T &operator[](int index) { return buffer[index]; }
  operator T *() { return buffer; }
  T *operator +(int offset) { return buffer + offset; }
  operator bool() const { return !!buffer; }
  T *operator->() const { return buffer; }

 private:
  AllocProxy(const AllocProxy &) {}
  AllocProxy &operator=(const AllocProxy &) {}
  T* buffer;
};

// 与std::unique_ptr一起使用以Release()无法删除的对象。
template <class T>
struct CFX_ReleaseDeleter {
  inline void operator()(T* ptr) const { ptr->Release(); }
};

//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#endif //__cplusplus
//<<<+++OPENSOURCE_MUST_END

#ifdef __cplusplus
extern "C" {
#endif

//*****************************************************************************
//* 固定内存管理
//*****************************************************************************
#define _FXMEM_NO64_
//#define  _FXMEM_LIT_

#define FX_FIXEDMEM_PAGESIZE    (4096 * 16)

#define FX_FIXEDMEM_MIDBLOCKSIZE  (4096)

typedef struct _FX_MEMCONFIG
{
  size_t  nPageNum_Init8;
  size_t  nPageNum_Init16;
  size_t  nPageNum_Init32;
  #if !defined(_FXMEM_NO64_)
    size_t  nPageNum_Init64;
  #endif

  size_t  nPageNum_More16;
  size_t  nPageNum_More32;
  #if !defined(_FXMEM_NO64_)
    size_t  nPageNum_More64;
  #endif
  #if defined(_FXMEM_LIT_)
    size_t  nPageSize_Lit;
    size_t  nPageNum_InitLit;
    size_t  nPageNum_MoreLit;
    size_t  nPageNum_ReservedLit;
  #endif

  size_t  nPageSize_Mid;
  size_t  nPageNum_InitMid;
  size_t  nPageNum_MoreMid;
  size_t  nPageSize_Large;
  size_t  nPageSize_Alone;
}FX_MEMCONFIG;

void  FXMEM_SetConfig(const FX_MEMCONFIG* memConfig);

//#define _FX_MEMSTATE_
#if defined(_FX_MEMSTATE_)

  typedef struct _FX_MEMPAGESTATE_
  {
    size_t  nCurMemSize;
    size_t  nMinMemSize;
    size_t  nMaxMemSize;
    size_t  nCurAvailSize;
    size_t  nMinAvailSize;
    size_t  nMaxAvailSize;
    size_t  nCurUsedSize;
    size_t  nMinUsedSize;
    size_t  nMaxUsedSize;
    size_t  nCurUsedRate;
    size_t  nMinUsedRate;
    size_t  nMaxUsedRate;
    size_t  bValid;
  }FX_MEMPAGESTATE;
  typedef struct _FX_MEMINFO_
  {
    size_t      memBlockCount[64];
    FX_MEMPAGESTATE  pageState8;
    FX_MEMPAGESTATE  pageState16;
    FX_MEMPAGESTATE  pageState32;
    FX_MEMPAGESTATE  pageStateMid;
    FX_MEMPAGESTATE  pageStateLarge;
    FX_MEMPAGESTATE  totalState;
  }FX_MEMINFO;

  #define FX_MEMSTATE_RATEFRACTION  100000

  void      FX_MemState_MergeInfo(FX_MEMINFO *mi1, const FX_MEMINFO *mi2);
  FX_MEMINFO*    FX_MemState_GetInfo();
  void      FX_MemState_ResetInfo();

#endif //_FX_MEMSTATE_

#ifdef __cplusplus
}
#endif

//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#endif //_FX_MEMORY_H_
//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_END