///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance").
|
// All rights reserved.
|
//
|
// This software and its documentation and related materials are owned by
|
// the Alliance. The software may only be incorporated into application
|
// programs owned by members of the Alliance, subject to a signed
|
// Membership Agreement and Supplemental Software License Agreement with the
|
// Alliance. The structure and organization of this software are the valuable
|
// trade secrets of the Alliance and its suppliers. The software is also
|
// protected by copyright law and international treaty provisions. Application
|
// programs incorporating this software must include the following statement
|
// with their copyright notices:
|
//
|
// This application incorporates Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance.
|
// All rights reserved.
|
//
|
// By use of this software, its documentation or related materials, you
|
// acknowledge and accept the above terms.
|
///////////////////////////////////////////////////////////////////////////////
|
|
#ifndef __CHUNK_ALLOCATOR__
|
#define __CHUNK_ALLOCATOR__
|
|
#include "RootExport.h"
|
#include "RxObjectImpl.h"
|
|
#include "TD_PackPush.h"
|
|
/** \details
|
<group Other_Classes>
|
*/
|
class FIRSTDLL_EXPORT IAllocator
|
{
|
public:
|
virtual void* alloc(int) = 0;
|
virtual void release(void* p) = 0;
|
virtual ~IAllocator() {}
|
|
IAllocator();
|
#ifdef _DEBUG
|
virtual int numChunks() = 0;
|
#endif
|
};
|
|
/** \details
|
<group Other_Classes>
|
*/
|
class FIRSTDLL_EXPORT AllocatorArray
|
{
|
public:
|
//'mask' is a bit flags value, each bit represents
|
// enhancedForFixedSize flag per item.
|
// If size > sizeof(mask) then the rest items have the flag '0'
|
AllocatorArray(unsigned size, int mask);
|
~AllocatorArray();
|
|
unsigned size() const { return m_size; }
|
IAllocator* getAt(unsigned i)
|
{
|
ODA_ASSERT(i < m_size);
|
return m_data[i];
|
}
|
|
protected:
|
IAllocator** m_data;
|
unsigned m_size;
|
};
|
|
FIRSTDLL_EXPORT void addLocalHeaps(unsigned nThreadId, const unsigned* aThreadId);
|
FIRSTDLL_EXPORT void releaseLocalHeaps(unsigned nThreadId, const unsigned* aThreadId);
|
|
// Prevent MFC memleaks displaying
|
|
/** \details
|
<group Other_Classes>
|
*/
|
class AllocatorArrayML : public AllocatorArray
|
{
|
protected:
|
bool m_bAllocated;
|
unsigned m_origSize;
|
int m_origMask;
|
|
void clear()
|
{
|
m_bAllocated = false;
|
m_data = NULL;
|
m_size = 0;
|
}
|
public:
|
AllocatorArrayML(unsigned size, int mask)
|
: AllocatorArray(size, mask)
|
, m_bAllocated(true), m_origSize(size), m_origMask(mask)
|
{ }
|
~AllocatorArrayML() { }
|
void reset()
|
{
|
if (!m_bAllocated)
|
{
|
AllocatorArrayML tmp(m_origSize, m_origMask);
|
*this = tmp;
|
tmp.clear();
|
}
|
}
|
void uninit()
|
{
|
if (m_bAllocated) {
|
this->~AllocatorArrayML();
|
clear();
|
}
|
}
|
};
|
|
// Some simplifiers for allocator specification
|
|
#define ODCA_HEAP_OPERATORS() \
|
void* operator new(size_t); \
|
void operator delete(void*)
|
|
#define ODCA_HEAP_ALLOCATOR() \
|
static AllocatorArrayML s_aAlloc
|
|
#define ODCA_HEAP_OPERATORS_DEFINE(baseClass, num) \
|
void* baseClass::operator new(size_t size) \
|
{ \
|
return s_aAlloc.getAt(num)->alloc((int)size); \
|
} \
|
void baseClass::operator delete(void* p) \
|
{ \
|
s_aAlloc.getAt(num)->release(p); \
|
}
|
|
#define ODCA_HEAP_OPERATORS_DEFINE_0(baseClass) \
|
ODCA_HEAP_OPERATORS_DEFINE(baseClass, 0)
|
|
#define ODCA_HEAP_ALLOCATOR_DEFINE(baseClass, numAllocs, allocMask) \
|
AllocatorArrayML baseClass::s_aAlloc(numAllocs, allocMask)
|
|
#define ODCA_HEAP_ALLOCATOR_DEFINE_1(baseClass) \
|
ODCA_HEAP_ALLOCATOR_DEFINE(baseClass, 1, 0)
|
#define ODCA_HEAP_ALLOCATOR_DEFINE_1_ENH(baseClass) \
|
ODCA_HEAP_ALLOCATOR_DEFINE(baseClass, 1, 1)
|
|
#define ODCA_HEAP_ALLOCATOR_RESET(baseClass) \
|
baseClass::s_aAlloc.reset()
|
#define ODCA_HEAP_ALLOCATOR_UNINIT(baseClass) \
|
baseClass::s_aAlloc.uninit()
|
|
/** \details
|
<group Other_Classes>
|
*/
|
template<class T, class TInterface = T>
|
class OdGiRxObjectReImpl : public OdRxObjectImpl<T, TInterface>
|
{
|
/** \details
|
Assignment operator prohibited.
|
*/
|
OdGiRxObjectReImpl& operator = (const OdGiRxObjectReImpl&) { return *this; }
|
|
protected:
|
void* operator new (size_t size) { return T::operator new (size); }
|
void operator delete (void* p) { T::operator delete (p); }
|
|
public:
|
/** \details
|
Creates an instance of OdGiRxObjectReImpl<T, TInterface>
|
and returns SmartPointer to it.
|
*/
|
static OdSmartPtr<TInterface> createObject()
|
{
|
return OdSmartPtr<TInterface>(static_cast<TInterface*>(new OdGiRxObjectReImpl<T, TInterface>), kOdRxObjAttach);
|
}
|
};
|
|
#define GIRXREIMPL_CONSTR(ClassName) OdGiRxObjectReImpl<ClassName>::createObject()
|
|
#include "TD_PackPop.h"
|
|
#endif // __CHUNK_ALLOCATOR__
|
