INOS
Classes | Macros | Variables
cinospartitionmemory.h File Reference

Short comment. More...

Go to the source code of this file.

Classes

class  CINOSPartitionMemory
 

Macros

#define INOS_CACHE   0
 
#define DECLARE_DYNAMIC(aClass)   DECLARE_DYNAMIC_POOL(aClass,0)
 
#define DECLARE_DYNAMIC_T(aClass, aT)   DECLARE_DYNAMIC_POOL_T(aClass,aT,0)
 
#define DECLARE_DYNAMIC_T2(aClass, aT1, aT2)   DECLARE_DYNAMIC_POOL_T2(aClass,aT1,aT2,0)
 
#define DECLARE_DYNAMIC_T3(aClass, aT1, aT2, aT3)   DECLARE_DYNAMIC_POOL_T3(aClass,aT1,aT2,aT3,0)
 
#define DECLARE_DYNAMIC_T4(aClass, aT1, aT2, aT3, aT4)   DECLARE_DYNAMIC_POOL_T4(aClass,aT1,aT2,aT3,aT4,0)
 
#define DECLARE_DYNAMIC_N(aClass, aN)   DECLARE_DYNAMIC_POOL_N(aClass,aN,0)
 
#define DECLARE_DYNAMIC_N2(aClass, aN, aM)   DECLARE_DYNAMIC_POOL_N2(aClass,aN,aM,0)
 
#define DECLARE_DYNAMIC_CACHE(aClass)   DECLARE_DYNAMIC_POOL(aClass,INOS_CACHE)
 
#define DECLARE_DYNAMIC_I(aClass, aInnerClass)   DECLARE_DYNAMIC_POOL_T(aClass,aInnerClass,0)
 
#define DECLARE_DYNAMIC_PLACEMENT(aClass)   DECLARE_DYNAMIC_POOL_PLACEMENT(aClass)
 
#define DECLARE_DYNAMIC_VARIADIC(aClass)   DECLARE_DYNAMIC_POOL_VARIADIC(aClass,0)
 
#define IMPLEMENT_DYNAMIC(aClass)   IMPLEMENT_DYNAMIC_POOL(aClass,0)
 
#define IMPLEMENT_DYNAMIC_T(aClass, aT)   IMPLEMENT_DYNAMIC_POOL_T(aClass,aT,0)
 
#define IMPLEMENT_DYNAMIC_T2(aClass, aT1, aT2)   IMPLEMENT_DYNAMIC_POOL_T2(aClass,aT1,aT2,0)
 
#define IMPLEMENT_DYNAMIC_T3(aClass, aT1, aT2, aT3)   IMPLEMENT_DYNAMIC_POOL_T3(aClass,aT1,aT2,aT3,0)
 
#define IMPLEMENT_DYNAMIC_T_S(aClass, aT, aS)   IMPLEMENT_DYNAMIC_POOL_T_S(aClass,aT,aS,0)
 
#define IMPLEMENT_DYNAMIC_T4(aClass, aT1, aT2, aT3, aT4)   IMPLEMENT_DYNAMIC_POOL_T4(aClass,aT1,aT2,aT3,aT4,0)
 
#define IMPLEMENT_DYNAMIC_N(aClass, aN)   IMPLEMENT_DYNAMIC_POOL_N(aClass,aN,0)
 
#define IMPLEMENT_DYNAMIC_N2(aClass, aN, aM)   IMPLEMENT_DYNAMIC_POOL_N2(aClass,aN,aM,0)
 
#define IMPLEMENT_DYNAMIC_CACHE(aClass)   IMPLEMENT_DYNAMIC_POOL(aClass,INOS_CACHE)
 
#define IMPLEMENT_DYNAMIC_I(aClass, aT)   IMPLEMENT_DYNAMIC_POOL_I(aClass,aT,0)
 
#define IMPLEMENT_DYNAMIC_PLACEMENT(aClass)   IMPLEMENT_DYNAMIC_POOL_PLACEMENT(aClass)
 
#define IMPLEMENT_DYNAMIC_PLACEMENT_N(aClass, N)   IMPLEMENT_DYNAMIC_POOL_PLACEMENT_N(aClass, N)
 
#define IMPLEMENT_DYNAMIC_T2_VARIADIC(aClass, aT1, aT2)   IMPLEMENT_DYNAMIC_POOL_T2_VARIADIC(aClass,aT1,aT2,0)
 
#define IMPLEMENT_DYNAMIC_T3_VARIADIC(aClass, aT1, aT2, aT3)   IMPLEMENT_DYNAMIC_POOL_T3_VARIADIC(aClass,aT1,aT2,aT3,0)
 
#define IMPLEMENT_DYNAMIC_T4_VARIADIC(aClass, aT1, aT2, aT3, aT4)   IMPLEMENT_DYNAMIC_POOL_T4_VARIADIC(aClass,aT1,aT2,aT3,aT4,0)
 
#define DF_HANDLE_MEMPOOL_CLASSNAME_ARG(i_Arg)
 
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(i_Statement)
 
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3(aStatement1, aStatement2, aStatement3)
 
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_4(aStatement1, aStatement2, aStatement3, aStatement4)
 
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_5(aStatement1, aStatement2, aStatement3, aStatement4, aStatement5)
 
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_10(aStatement1, aStatement2, aStatement3, aStatement4, aStatement5, aStatement6, aStatement7, aStatement8, aStatement9, aStatement10)
 
#define DECLARE_DYNAMIC_POOL(aClass, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL(aClass, aPool)
 
#define DECLARE_DYNAMIC_POOL_PLACEMENT(aClass)
 
#define IMPLEMENT_DYNAMIC_POOL_PLACEMENT(aClass)
 
#define IMPLEMENT_DYNAMIC_POOL_PLACEMENT_N(aClass, N)
 
#define DECLARE_DYNAMIC_POOL_T(aClass, aT, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_T(aClass, aT, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_T_S(aClass, aT, aS, aPool)
 
#define DECLARE_DYNAMIC_POOL_T2(aClass, aT1, aT2, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_T2(aClass, aT1, aT2, aPool)
 
#define DECLARE_DYNAMIC_POOL_T3(aClass, aT1, aT2, aT3, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_T3(aClass, aT1, aT2, aT3, aPool)
 
#define DECLARE_DYNAMIC_POOL_T4(aClass, aT1, aT2, aT3, aT4, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_T4(aClass, aT1, aT2, aT3, aT4, aPool)
 
#define DECLARE_DYNAMIC_POOL_N(aClass, aN, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_N(aClass, aN, aPool)
 
#define DECLARE_DYNAMIC_POOL_N2(aClass, aN, aM, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_N2(aClass, aN, aM, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_I(aClass, aInnerClass, aPool)
 
#define DECLARE_DYNAMIC_POOL_VARIADIC(aClass, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_T4_VARIADIC(aClass, aT1, aT2, aT3, aT4, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_T3_VARIADIC(aClass, aT1, aT2, aT3, aPool)
 
#define IMPLEMENT_DYNAMIC_POOL_T2_VARIADIC(aClass, aT1, aT2, aPool)
 

Variables

end of doxygen exclude
 

Detailed Description

Short comment.

Author
Ch. Hirzel
Copyright
Copyright © 2016 Indel AG. All rights reserved.
This software is licensed on a non-exclusive basis for use on Indel products only. If the Source Code has been provided by Indel, the software may be modified or further developed, exclusively for the use on Indel's products. For evaluation purposes of the aforementioned development or modification of the software, the software may temporarily be used on third party products. Any further use of this software, its modification or development on non-Indel products is strictly prohibited.
Remarks
project         : 
language        : GNU C++
system          :

Long comment on this file.

Macro Definition Documentation

◆ DECLARE_DYNAMIC

#define DECLARE_DYNAMIC (   aClass)    DECLARE_DYNAMIC_POOL(aClass,0)

By using this macro within the class declaration the INOS memory management is being used for that class when creating objects of it using operator new and delete.

◆ DECLARE_DYNAMIC_I

#define DECLARE_DYNAMIC_I (   aClass,
  aInnerClass 
)    DECLARE_DYNAMIC_POOL_T(aClass,aInnerClass,0)

Use this macro for inner classes

Note
The "template version" can be reused.

◆ DECLARE_DYNAMIC_N

#define DECLARE_DYNAMIC_N (   aClass,
  aN 
)    DECLARE_DYNAMIC_POOL_N(aClass,aN,0)

Use this macro for template classes with one integer template argument

◆ DECLARE_DYNAMIC_N2

#define DECLARE_DYNAMIC_N2 (   aClass,
  aN,
  aM 
)    DECLARE_DYNAMIC_POOL_N2(aClass,aN,aM,0)

Use this macro for template classes with two integer template argument

◆ DECLARE_DYNAMIC_PLACEMENT

#define DECLARE_DYNAMIC_PLACEMENT (   aClass)    DECLARE_DYNAMIC_POOL_PLACEMENT(aClass)

Use this macro, additionally to e.g. DECLARE_DYNAMIC, to provide the 'placement operator new'

◆ DECLARE_DYNAMIC_POOL

#define DECLARE_DYNAMIC_POOL (   aClass,
  aPool 
)
Value:
static CINOSPartitionMemory* p##aClass##Memory; \
static uint32 u##aClass##Memory; \
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##Name;) \
public: \
void* operator new(size_t aSize); \
void operator delete(void* aPtr);
CINOSMcModuleWaitVar
Definition cinosmcmodule.h:1900
CINOSPartitionMemory
Definition cinospartitionmemory.h:157

◆ DECLARE_DYNAMIC_POOL_N

#define DECLARE_DYNAMIC_POOL_N (   aClass,
  aN,
  aPool 
)
Value:
static CINOSPartitionMemory* p##aClass##aN##Memory; \
static uint32 u##aClass##aN##Memory; \
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aN##Name;)\
public: \
void* operator new(size_t aSize) \
{ \
INOS_ADD_(u##aClass##aN##Memory, 1); \
return p##aClass##aN##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aN##Name));\
} \
void operator delete(void* aPtr) \
{ \
bool bFreed = p##aClass##aN##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aN##Name));\
if(bFreed) INOS_ADD_(u##aClass##aN##Memory, -1); \
}
DF_HANDLE_MEMPOOL_CLASSNAME_ARG
#define DF_HANDLE_MEMPOOL_CLASSNAME_ARG(i_Arg)
Definition cinospartitionmemory.h:404
INOS_ADD_
#define INOS_ADD_
Definition inosmacro.h:326

◆ DECLARE_DYNAMIC_POOL_N2

#define DECLARE_DYNAMIC_POOL_N2 (   aClass,
  aN,
  aM,
  aPool 
)
Value:
static CINOSPartitionMemory* p##aClass##aN##aM##Memory; \
static uint32 u##aClass##aN##aM##Memory; \
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aN##aM##Name;)\
public: \
void* operator new(size_t aSize) \
{ \
INOS_ADD_(u##aClass##aN##aM##Memory, 1); \
return p##aClass##aN##aM##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aN##aM##Name));\
} \
void operator delete(void* aPtr) \
{ \
bool bFreed = p##aClass##aN##aM##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aN##aM##Name));\
if(bFreed) INOS_ADD_(u##aClass##aN##aM##Memory, -1); \
}

◆ DECLARE_DYNAMIC_POOL_PLACEMENT

#define DECLARE_DYNAMIC_POOL_PLACEMENT (   aClass)
Value:
public: \
void* operator new(size_t aSize, void*);

◆ DECLARE_DYNAMIC_POOL_T

#define DECLARE_DYNAMIC_POOL_T (   aClass,
  aT,
  aPool 
)
Value:
static CINOSPartitionMemory* p##aClass##aT##Memory; \
static uint32 u##aClass##aT##Memory; \
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aT##Name;) \
public: \
void* operator new(size_t aSize) \
{ \
INOS_ADD_(u##aClass##aT##Memory, 1); \
return p##aClass##aT##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT##Name)); \
} \
void operator delete(void* aPtr) \
{ \
bool bFreed = p##aClass##aT##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT##Name)); \
if(bFreed) INOS_ADD_(u##aClass##aT##Memory, -1); \
}

◆ DECLARE_DYNAMIC_POOL_T2

#define DECLARE_DYNAMIC_POOL_T2 (   aClass,
  aT1,
  aT2,
  aPool 
)
Value:
static CINOSPartitionMemory* p##aClass##aT1##aT2##Memory; \
static uint32 u##aClass##aT1##aT2##Memory; \
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aT1##aT2##Name;) \
public: \
void* operator new(size_t aSize) \
{ \
INOS_ADD_(u##aClass##aT1##aT2##Memory, 1); \
return p##aClass##aT1##aT2##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##Name)); \
} \
void operator delete(void* aPtr) \
{ \
bool bFreed = p##aClass##aT1##aT2##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##Name)); \
if(bFreed) INOS_ADD_(u##aClass##aT1##aT2##Memory, -1); \
}

◆ DECLARE_DYNAMIC_POOL_T3

#define DECLARE_DYNAMIC_POOL_T3 (   aClass,
  aT1,
  aT2,
  aT3,
  aPool 
)
Value:
static CINOSPartitionMemory* p##aClass##aT1##aT2##aT3##Memory; \
static uint32 u##aClass##aT1##aT2##aT3##Memory; \
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aT1##aT2##aT3##Name;) \
public: \
void* operator new(size_t aSize) \
{ \
INOS_ADD_(u##aClass##aT1##aT2##aT3##Memory, 1); \
return p##aClass##aT1##aT2##aT3##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##aT3##Name)); \
} \
void operator delete(void* aPtr) \
{ \
bool bFreed = p##aClass##aT1##aT2##aT3##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##aT3##Name)); \
if(bFreed) INOS_ADD_(u##aClass##aT1##aT2##aT3##Memory, -1); \
}

◆ DECLARE_DYNAMIC_POOL_T4

#define DECLARE_DYNAMIC_POOL_T4 (   aClass,
  aT1,
  aT2,
  aT3,
  aT4,
  aPool 
)
Value:
static CINOSPartitionMemory* p##aClass##aT1##aT2##aT3##aT4##Memory; \
static uint32 u##aClass##aT1##aT2##aT3##aT4##Memory; \
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aT1##aT2##aT3##aT4##Name;) \
public: \
void* operator new(size_t aSize) \
{ \
INOS_ADD_(u##aClass##aT1##aT2##aT3##aT4##Memory, 1); \
return p##aClass##aT1##aT2##aT3##aT4##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##aT3##aT4##Name)); \
} \
void operator delete(void* aPtr) \
{ \
bool bFreed = p##aClass##aT1##aT2##aT3##aT4##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##aT3##aT4##Name)); \
if(bFreed) INOS_ADD_(u##aClass##aT1##aT2##aT3##aT4##Memory, -1); \
}

◆ DECLARE_DYNAMIC_POOL_VARIADIC

#define DECLARE_DYNAMIC_POOL_VARIADIC (   aClass,
  aPool 
)
Value:
static CINOSPartitionMemory* pMemory; \
static uint32 uMemory; \
static const char* sName; \
public: \
void* operator new(size_t aSize); \
void operator delete(void* aPtr);

◆ DECLARE_DYNAMIC_T

#define DECLARE_DYNAMIC_T (   aClass,
  aT 
)    DECLARE_DYNAMIC_POOL_T(aClass,aT,0)

Use this macro for template classes with one template argument

◆ DECLARE_DYNAMIC_T2

#define DECLARE_DYNAMIC_T2 (   aClass,
  aT1,
  aT2 
)    DECLARE_DYNAMIC_POOL_T2(aClass,aT1,aT2,0)

Use this macro for template classes with two template argumenta

◆ DECLARE_DYNAMIC_T3

#define DECLARE_DYNAMIC_T3 (   aClass,
  aT1,
  aT2,
  aT3 
)    DECLARE_DYNAMIC_POOL_T3(aClass,aT1,aT2,aT3,0)

Use this macro for template classes with three template argumenta

◆ DECLARE_DYNAMIC_T4

#define DECLARE_DYNAMIC_T4 (   aClass,
  aT1,
  aT2,
  aT3,
  aT4 
)    DECLARE_DYNAMIC_POOL_T4(aClass,aT1,aT2,aT3,aT4,0)

Use this macro for template classes with four template arguments

◆ DECLARE_DYNAMIC_VARIADIC

#define DECLARE_DYNAMIC_VARIADIC (   aClass)    DECLARE_DYNAMIC_POOL_VARIADIC(aClass,0)

Use this macro for template classes with any number of template arguments and variadic arguments as their last template argument, such as here: \begincode template <typename T1, typename T2, typename T3, typename ... TArgs> class Example {...};

◆ DF_HANDLE_MEMPOOL_CLASSNAME_ARG

#define DF_HANDLE_MEMPOOL_CLASSNAME_ARG (   i_Arg)

Macro used to differentiate between enabled "Secure partition" or not. Neccessary because the "secure" version should pass the class name - whereas the "non secure" does not even have such a class name.

◆ IMPLEMENT_DYNAMIC

#define IMPLEMENT_DYNAMIC (   aClass)    IMPLEMENT_DYNAMIC_POOL(aClass,0)

By using this macro within the class implementation the INOS memory management is being used for that class when creating objects of it using operator new and delete.

◆ IMPLEMENT_DYNAMIC_N

#define IMPLEMENT_DYNAMIC_N (   aClass,
  aN 
)    IMPLEMENT_DYNAMIC_POOL_N(aClass,aN,0)

Use this macro for template classes with one integer template argument

◆ IMPLEMENT_DYNAMIC_N2

#define IMPLEMENT_DYNAMIC_N2 (   aClass,
  aN,
  aM 
)    IMPLEMENT_DYNAMIC_POOL_N2(aClass,aN,aM,0)

Use this macro for template classes with two integer template argument

◆ IMPLEMENT_DYNAMIC_POOL

#define IMPLEMENT_DYNAMIC_POOL (   aClass,
  aPool 
)
Value:
CINOSPartitionMemory* aClass::p##aClass##Memory = \
CINOSPartitionMemory::Create(sizeof(aClass),aPool,#aClass,&aClass::u##aClass##Memory); \
uint32 aClass::u##aClass##Memory = 0; \
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(const char* aClass::s##aClass##Name = #aClass;) \
void* aClass::operator new(size_t aSize) \
{ \
INOS_ADD(aClass::u##aClass##Memory, 1); \
return p##aClass##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##Name));\
} \
void aClass::operator delete(void* aPtr) \
{ \
bool bFreed = p##aClass##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##Name)); \
if(bFreed) INOS_ADD(aClass::u##aClass##Memory, -1); \
}
INOS_ADD
#define INOS_ADD(variable, value)
Definition inosmacro.h:220

◆ IMPLEMENT_DYNAMIC_POOL_I

#define IMPLEMENT_DYNAMIC_POOL_I (   aClass,
  aInnerClass,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(const char* aClass::aInnerClass::s##aClass##aInnerClass##Name = #aClass#aInnerClass;) \
CINOSPartitionMemory* aClass::aInnerClass::p##aClass##aInnerClass##Memory =\
CINOSPartitionMemory::Create(sizeof(aClass::aInnerClass),aPool,#aClass#aInnerClass,&aClass::aInnerClass::u##aClass##aInnerClass##Memory); \
uint32 aClass::aInnerClass::u##aClass##aInnerClass##Memory = 0;

◆ IMPLEMENT_DYNAMIC_POOL_N

#define IMPLEMENT_DYNAMIC_POOL_N (   aClass,
  aN,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(template< int aN> const char* aClass< aN >::s##aClass##aN##Name = #aClass#aN;) \
template< int aN> CINOSPartitionMemory* aClass< aN >::p##aClass##aN##Memory = \
CINOSPartitionMemory::Create(sizeof(aClass< aN >),aPool,#aClass#aN,&aClass< aN >::u##aClass##aN##Memory);\
template< int aN> uint32 aClass< aN >::u##aClass##aN##Memory = 0;

◆ IMPLEMENT_DYNAMIC_POOL_N2

#define IMPLEMENT_DYNAMIC_POOL_N2 (   aClass,
  aN,
  aM,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3(template< int aN, int aM > const char* aClass< aN, aM >::s##aClass##aN##aM##Name = #aClass#aN#aM;) \
template< int aN, int aM > CINOSPartitionMemory* aClass< aN, aM >::p##aClass##aN##aM##Memory = \
CINOSPartitionMemory::Create(sizeof(aClass< aN, aM >),aPool,#aClass#aN#aM,&aClass< aN, aM >::u##aClass##aN##aM##Memory); \
template< int aN, int aM > uint32 aClass< aN, aM >::u##aClass##aN##aM##Memory = 0;

◆ IMPLEMENT_DYNAMIC_POOL_PLACEMENT

#define IMPLEMENT_DYNAMIC_POOL_PLACEMENT (   aClass)
Value:
void* aClass::operator new(size_t aSize, void* aAddress) \
{ \
return aAddress; \
}

◆ IMPLEMENT_DYNAMIC_POOL_PLACEMENT_N

#define IMPLEMENT_DYNAMIC_POOL_PLACEMENT_N (   aClass,
  N 
)
Value:
template< int aN> void* aClass< aN >::operator new(size_t aSize, void* aAddress)\
{ \
return aAddress; \
}

◆ IMPLEMENT_DYNAMIC_POOL_T

#define IMPLEMENT_DYNAMIC_POOL_T (   aClass,
  aT,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(template< class aT > const char* aClass< aT >::s##aClass##aT##Name = #aClass#aT;) \
template< class aT > CINOSPartitionMemory* aClass< aT >::p##aClass##aT##Memory =\
CINOSPartitionMemory::Create(sizeof(aClass< aT >),aPool,#aClass#aT,&aClass< aT >::u##aClass##aT##Memory); \
template< class aT > uint32 aClass< aT >::u##aClass##aT##Memory = 0;

◆ IMPLEMENT_DYNAMIC_POOL_T2

#define IMPLEMENT_DYNAMIC_POOL_T2 (   aClass,
  aT1,
  aT2,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3(template< class aT1, class aT2 > const char* aClass< aT1, aT2 >::s##aClass##aT1##aT2##Name = #aClass#aT1#aT2;) \
template< class aT1, class aT2 > CINOSPartitionMemory* aClass< aT1, aT2 >::p##aClass##aT1##aT2##Memory =\
CINOSPartitionMemory::Create(sizeof(aClass< aT1, aT2 >),aPool,#aClass#aT1#aT2,&aClass< aT1, aT2 >::u##aClass##aT1##aT2##Memory); \
template< class aT1, class aT2 > uint32 aClass< aT1, aT2 >::u##aClass##aT1##aT2##Memory = 0;

◆ IMPLEMENT_DYNAMIC_POOL_T2_VARIADIC

#define IMPLEMENT_DYNAMIC_POOL_T2_VARIADIC (   aClass,
  aT1,
  aT2,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3( \
template< class aT1, class ... aT2 > \
const char* aClass< aT1, aT2 ... >::sName = #aClass"<"#aT1"_"#aT2">";) \
template< class aT1, class ... aT2> \
CINOSPartitionMemory* aClass< aT1, aT2 ... >::pMemory = \
CINOSPartitionMemory::Create( \
sizeof(aClass< aT1, aT2 ... >),aPool,#aClass"<"#aT1"_"#aT2">", \
&aClass< aT1, aT2 ... >::uMemory); \
template< class aT1, class ... aT2> uint32 aClass< aT1, aT2 ... >::uMemory = 0; \
template< class aT1, class ... aT2> \
void* aClass< aT1, aT2 ... >::operator new(size_t aSize) { \
INOS_ADD_(uMemory, 1); \
return pMemory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName)); \
} \
template< class aT1, class ... aT2> \
void aClass< aT1, aT2 ... >::operator delete(void* aPtr) { \
bool bFreed = pMemory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName)); \
if(bFreed) INOS_ADD_(uMemory, -1); \
}

◆ IMPLEMENT_DYNAMIC_POOL_T3

#define IMPLEMENT_DYNAMIC_POOL_T3 (   aClass,
  aT1,
  aT2,
  aT3,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_5(template< class aT1, class aT2, class aT3 > const char* aClass< aT1, aT2, aT3 >::s##aClass##aT1##aT2##aT3##Name = #aClass#aT1#aT2#aT3;) \
template< class aT1, class aT2, class aT3 > CINOSPartitionMemory* aClass< aT1, aT2, aT3 >::p##aClass##aT1##aT2##aT3##Memory =\
CINOSPartitionMemory::Create(sizeof(aClass< aT1, aT2, aT3 >),aPool,#aClass#aT1#aT2#aT3,&aClass< aT1, aT2, aT3 >::u##aClass##aT1##aT2##aT3##Memory); \
template< class aT1, class aT2, class aT3 > uint32 aClass< aT1, aT2, aT3 >::u##aClass##aT1##aT2##aT3##Memory = 0;

◆ IMPLEMENT_DYNAMIC_POOL_T3_VARIADIC

#define IMPLEMENT_DYNAMIC_POOL_T3_VARIADIC (   aClass,
  aT1,
  aT2,
  aT3,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_5( \
template< class aT1, class aT2, class ... aT3 > \
const char* aClass< aT1, aT2, aT3 ... >::sName = #aClass"<"#aT1"_"#aT2"_"#aT3">";) \
template< class aT1, class aT2, class ... aT3> \
CINOSPartitionMemory* aClass< aT1, aT2, aT3 ... >::pMemory = \
CINOSPartitionMemory::Create( \
sizeof(aClass< aT1, aT2, aT3 ... >),aPool,#aClass"<"#aT1"_"#aT2"_"#aT3">", \
&aClass< aT1, aT2, aT3 ... >::uMemory); \
template< class aT1, class aT2, class ... aT3> \
uint32 aClass< aT1, aT2, aT3 ... >::uMemory = 0; \
template< class aT1, class aT2, class ... aT3> \
void* aClass< aT1, aT2, aT3 ... >::operator new(size_t aSize) { \
INOS_ADD_(uMemory, 1); \
return pMemory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName)); \
} \
template< class aT1, class aT2, class ... aT3> \
void aClass< aT1, aT2, aT3 ... >::operator delete(void* aPtr) { \
bool bFreed = pMemory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName)); \
if(bFreed) INOS_ADD_(uMemory, -1); \
}

◆ IMPLEMENT_DYNAMIC_POOL_T4

#define IMPLEMENT_DYNAMIC_POOL_T4 (   aClass,
  aT1,
  aT2,
  aT3,
  aT4,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_7(template< class aT1, class aT2, class aT3, class aT4 > const char* aClass< aT1, aT2, aT3, aT4 >::s##aClass##aT1##aT2##aT3##aT4##Name = #aClass#aT1#aT2#aT3#aT4;) \
template< class aT1, class aT2, class aT3, class aT4 > CINOSPartitionMemory* aClass< aT1, aT2, aT3, aT4 >::p##aClass##aT1##aT2##aT3##aT4##Memory =\
CINOSPartitionMemory::Create(sizeof(aClass< aT1, aT2, aT3, aT4 >),aPool,#aClass#aT1#aT2#aT3#aT4,&aClass< aT1, aT2, aT3, aT4 >::u##aClass##aT1##aT2##aT3##aT4##Memory); \
template< class aT1, class aT2, class aT3, class aT4 > uint32 aClass< aT1, aT2, aT3, aT4 >::u##aClass##aT1##aT2##aT3##aT4##Memory = 0;

◆ IMPLEMENT_DYNAMIC_POOL_T4_VARIADIC

#define IMPLEMENT_DYNAMIC_POOL_T4_VARIADIC (   aClass,
  aT1,
  aT2,
  aT3,
  aT4,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_7( \
template< class aT1, class aT2, class aT3, class ... aT4 > \
const char* aClass< aT1, aT2, aT3, aT4 ... >::sName = #aClass"<"#aT1"_"#aT2"_"#aT3"_"#aT4">";) \
template< class aT1, class aT2, class aT3, class ... aT4> \
CINOSPartitionMemory* aClass< aT1, aT2, aT3, aT4 ... >::pMemory = \
CINOSPartitionMemory::Create( \
sizeof(aClass< aT1, aT2, aT3, aT4 ... >),aPool,#aClass"<"#aT1"_"#aT2"_"#aT3"_"#aT4">", \
&aClass< aT1, aT2, aT3, aT4 ... >::uMemory); \
template< class aT1, class aT2, class aT3, class ... aT4> \
uint32 aClass< aT1, aT2, aT3, aT4 ... >::uMemory = 0; \
template< class aT1, class aT2, class aT3, class ... aT4> \
void* aClass< aT1, aT2, aT3, aT4 ... >::operator new(size_t aSize) { \
INOS_ADD_(uMemory, 1); \
return pMemory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName)); \
} \
template< class aT1, class aT2, class aT3, class ... aT4> \
void aClass< aT1, aT2, aT3, aT4 ... >::operator delete(void* aPtr) { \
bool bFreed = pMemory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName)); \
if(bFreed) INOS_ADD_(uMemory, -1); \
}

◆ IMPLEMENT_DYNAMIC_POOL_T_S

#define IMPLEMENT_DYNAMIC_POOL_T_S (   aClass,
  aT,
  aS,
  aPool 
)
Value:
DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(const char* aClass< aS >::s##aClass##aT##Name = #aClass#aS;) \
CINOSPartitionMemory* aClass< aS >::p##aClass##aT##Memory =\
CINOSPartitionMemory::Create(sizeof(aClass< aS >),aPool,#aClass#aS,&aClass< aS >::u##aClass##aT##Memory); \
uint32 aClass< aS >::u##aClass##aT##Memory = 0;

◆ IMPLEMENT_DYNAMIC_T

#define IMPLEMENT_DYNAMIC_T (   aClass,
  aT 
)    IMPLEMENT_DYNAMIC_POOL_T(aClass,aT,0)

Use this macro for template classes with one template argument

◆ IMPLEMENT_DYNAMIC_T2

#define IMPLEMENT_DYNAMIC_T2 (   aClass,
  aT1,
  aT2 
)    IMPLEMENT_DYNAMIC_POOL_T2(aClass,aT1,aT2,0)

Use this macro for template classes with two template argumenta

◆ IMPLEMENT_DYNAMIC_T3

#define IMPLEMENT_DYNAMIC_T3 (   aClass,
  aT1,
  aT2,
  aT3 
)    IMPLEMENT_DYNAMIC_POOL_T3(aClass,aT1,aT2,aT3,0)

Use this macro for template classes with three template argumenta

◆ IMPLEMENT_DYNAMIC_T4

#define IMPLEMENT_DYNAMIC_T4 (   aClass,
  aT1,
  aT2,
  aT3,
  aT4 
)    IMPLEMENT_DYNAMIC_POOL_T4(aClass,aT1,aT2,aT3,aT4,0)

Use this macro for template classes with four template arguments

◆ IMPLEMENT_DYNAMIC_T_S

#define IMPLEMENT_DYNAMIC_T_S (   aClass,
  aT,
  aS 
)    IMPLEMENT_DYNAMIC_POOL_T_S(aClass,aT,aS,0)

Use this macro for template class specialization with one template argument