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);

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);    \
        }

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);     \
        }

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