XMemoryMacros.h

Go to the documentation of this file.

//! @file XMemoryMacros.h
//! @brief definitions of macros for SDK new / delete / allocation operators.
//
//////////////////////////////////////////////////////////////////////////
// Based on the file MemoryMacros.hpp by Alessandro Di Meco
//
// Defines allocation macros :
//      xNew, xNewParams, xDelete => allocate a single object (calling constructor and destructor)
//      xNewArray, xDeleteArray => allocate an array of object (calling constructor and destructor)
//      xAllocateArray, xDeallocateArray => allocate raw data, without any constructor or destructor calls)
//
// cf. Note on performance below
 
#if !defined(CXMEMORYMACROS_INCLUDE_H)
#define CXMEMORYMACROS_INCLUDE_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
// if MOOTOOLS_USE_NEW_AND_DELETE is not defined, we use a custom allocator
// that allows to perform callback on any allocation.
// Otherwise we use the standard c++ new and delete allocator
#ifndef MOOTOOLS_USE_NEW_AND_DELETE
    #include <assert.h>
 
    BEGIN_MOOTOOLS_NAMESPACE
 
    //! @name Template functions for constructing and deleting objects
    //!
    //! @note Compiler optimization removes these functions if the calling class has no constructor or destructor.\n
    //! This means that it does not consume any time when called on basic types (float, int...)\n
    //! this also means that xAllocateArray / xDeallocateArray and xNewArray / xDeleteArray has similar performance for basic types.\n
    //! Anyway xDeallocateArray has the advantage that it does not requires any count parameters.\n
    //! 
    //! @{
    template < typename T >
    void xTDestroy(T* p_pointer)
    {
        if (p_pointer != 0)
            p_pointer->~T();
    }
 
    template<typename T>
    T* xTConstructArray(T* p_pointer, size_t p_count)
    {
        assert(!p_count || p_pointer);
 
        T* currentPointer = p_pointer;
        const T* endPointer = p_pointer + p_count;
 
        while (currentPointer < endPointer)
        {
            ::new(currentPointer++)T;
        }
 
        return p_pointer;
    }
 
    template<typename T>
    void xTDestroyArray(const T* p_pointer, size_t p_count)
    {
        assert(!p_count || p_pointer);
        if (p_pointer == 0)
            return;
 
        // The while-loop uses a descending order to preserve the canonical destruction order of C++
        const T* current = p_pointer + p_count;
 
        while (p_count--)
        {
            (--current)->~T();
        }
    }
 
    template <typename T, bool is_poly>
    struct xTCast2
    {
       static void* cast (T* ptr) { return ptr; }
    };
 
    template <typename T>
    struct xTCast2<T, true>
    {
       static void* cast (T* ptr) { return dynamic_cast<void*>(ptr); }
    };
 
    template < typename T >
    void *xTCast(T *p_pointer)
    {
        return xTCast2<T, __is_polymorphic(T)>::cast(p_pointer);
    }
 
    //! @}
 
    // Private macros, not to be used
    //
    // These macros allow additional check in debugging mode
    // to control if xAllocate has a pending xDeallocate, xNew/xdelete, xNewArray/xDeleteArray, ...
    #define xAllocateFunc(p_type, xfunc) \
        (p_type *)mootools::xfunc(sizeof(p_type))
 
    #define xDeallocateFunc(p_pointer, xfunc) \
        mootools::xfunc(p_pointer)
 
    #define xAllocateArrayFunc(p_type, p_count, xfunc) \
        (p_type *)mootools::xfunc(sizeof(p_type), p_count)
 
    #define xDeallocateArrayFunc(p_pointer, p_count, xfunc) \
        mootools::xfunc(p_pointer, p_count)
 
    //! @name Simple memory block allocation
    //! 
    //! * xAllocate: Allocates memory for a single of type p_type.\n
    //! * xAllocateArray: Allocates memory for an array of type p_type.\n
    //! * xDeallocate: Deallocate memory pointed by p_pointer.\n
    //! * xDeallocateArray: Deallocate an memory array pointed by p_pointer.\n
    //!
    //! @param p_type The type of object to allocate.
    //!
    //! @return A pointer to the allocated memory.
    //!
    //! @note xAllocation has no reallocation possibilities.\n
    //! This introduces incompatibility when MOOTOOLS_USE_NEW_AND_DELETE is defined, because malloc / free allocation are made using a new operator\n
    //! you can use *xmalloc*, **xfree** and **xrealloc** instead xAllocate if you want to perform standard reallocation.
    //! 
    //! cf. note below
    //! @{
    #define xAllocate(p_type) \
        xAllocateFunc(p_type, xmalloc)
 
    #define xDeallocate(p_pointer, xfunc) \
        xDeallocateFunc(p_type, xfree)
 
    #define xAllocateArray(p_type, p_count) \
        xAllocateArrayFunc(p_type, p_count, xmalloc_array)
 
    #define xDeallocateArray(p_pointer) \
        xDeallocateArrayFunc(p_pointer, 1, xfree_array)
 
    //! @}
 
    //! @name In-place constructor / destructor
    //! 
    //! * xConstruct: Construct an object of type p_type at the specified memory location.
    //! * xConstructParams: Construct an object of type p_type at the specified memory location and using specific parameters.
    //! * xDestroy: Destroy an object pointed by p_pointer.
    //! * xConstructArray: Construct an array of objects of type p_type at the specified memory location.
    //! * xDestroyArray: Destroy an array of objects pointed by p_pointer.
    //!
    //! @param p_type The type of object to construct.
    //! @param p_pointer The memory location of the object.
    //! @param p_count Le length of the array.
    //!
    //! @return A pointer to the constructed object.
    //! @{
    #define xConstruct(p_type, p_pointer) \
        new (p_pointer)p_type
 
    #define xConstructParams(p_type, p_pointer, ...) \
        new (p_pointer)p_type(__VA_ARGS__)
 
    #define xConstructArray(p_type, p_pointer, p_count) \
        mootools::xTConstructArray<p_type>(p_pointer, p_count)
 
    #define xDestroyArray(p_pointer, p_count) \
        mootools::xTDestroyArray(p_pointer, p_count)
 
    #define xDestroy(p_pointer) \
        mootools::xTDestroy(p_pointer)
 
    //! @}
 
    //! @name Memory and inheritance
    //! xCast is used to correctly destroy the memory allocated by an object in case of multi inheritance\n
    //! using dynamic_cast for polymorphic object only. Without that the following code fails:\n
    //! if class AB : public A, public B\n
    //! AB *ab = xNew(AB); \n
    //! B *b = (B *)ab; => b points to B object. b pointer is not egal to ab which is the allocated memory\n
    //! xDelete(b); => fails, b value was never allocated\n
    //! 
    //! @note xCast is automatically called by xNew, xDelete, xDeleteArray, so you don't have to worry
    #define xCast(p_pointer) \
        mootools::xTCast(p_pointer)
 
    //! @name New and delete operators
    //! 
    //! * xNew: Construct an object of type p_type. Intended to be used in place of the default new operator.\n
    //! * xNewParams: Construct an object, providing constructor parameters in place of the default new operator
    //! * xNewArray: Creates an array of type p_type. Intended to be used in place of the default new[] operator.\n
    //! * xDelete: Deletes an object. Intended to be used in place of the default delete operator.\n
    //! * xDeleteArray: Deletes an array. Intended to be used in place of the default delete[] operator.\n
    //! 
    //! @param p_type The type of object to create.\n
    //! @param p_count The length of the array.\n
    //!
    //! @note If p_type is a template with multiple argument (separated by a comma)
    //! macro expansion fails. use a typedef in this case
    //! @{
    #define xNew(p_type) \
        xConstruct(p_type, (xAllocateFunc(p_type, xnew)))
 
    #define xNewParams(p_type, ...) \
        xConstructParams(p_type, xAllocateFunc(p_type, xnew), __VA_ARGS__)
 
    #define xNewArray(p_type, p_count) \
        xConstructArray(p_type, xAllocateArrayFunc(p_type, p_count, xnew_array), p_count)
 
    #define xDelete(p_pointer) \
    { \
        void *dynamic_casted_ptr = xCast(p_pointer); \
        xDestroy(p_pointer); \
        xDeallocateFunc(dynamic_casted_ptr, xdelete); \
    }
 
    #define xDeleteArray(p_pointer, p_count) \
    { \
        void *dynamic_casted_ptr = xCast(p_pointer); \
        xDestroyArray(p_pointer, p_count); \
        xDeallocateArrayFunc(dynamic_casted_ptr, p_count, xdelete_array); \
    }
 
    //! @}
    END_MOOTOOLS_NAMESPACE
#else // MOOTOOLS_USE_NEW_AND_DELETE
    // take advantage of MFC allocator if present
    #if defined(_DEBUG) && defined(MOOTOOLS_MFC_PRODUCT_BUILD)
        // Use MFC allocator. Cf. Note about memory leaks in XMemory.cpp
        #define new1 DEBUG_NEW
        #define new2 new // inplace new
    #else
        #define new1 new
        #define new2 new
    #endif
 
    // Macros call the standard new / delete operator
    // Note: xAllocate / xAllocateArray are allocated by new, meaning that xrealloc cannot be called
    #define xAllocate(p_type) \
        new1 p_type
 
    #define xAllocateArray(p_type, p_count) \
        new1 p_type[p_count]
 
    #define xDeallocateArray(p_pointer) \
        delete [] p_pointer
 
    #define xDeallocateArraySetNull(p_pointer) \
            { \
                delete [] p_pointer; \
                p_pointer = NULL; \
            }
    
    #define xConstruct(p_type, p_pointer) \
        new2 (p_pointer)p_type
 
    #define xConstructParams(p_type, p_pointer, ...) \
        new2 (p_pointer)p_type(__VA_ARGS__)
 
    #define xNew(p_type) \
        new1 p_type
 
    #define xNewParams(p_type, ...) \
        new1 p_type(__VA_ARGS__)
 
    #define xNewArray(p_type, p_count) \
        new1 p_type[p_count]
 
    #define xDelete(p_pointer) \
        delete p_pointer
 
    #define xDeleteSetNull(p_pointer) \
            { \
                delete p_pointer; \
                p_pointer = NULL; \
            }
 
    #define xDeleteArray(p_pointer, p_count) \
            delete [] p_pointer
 
    #define xDeleteArraySetNull(p_pointer, p_count) \
            { \
                delete [] p_pointer; \
                p_pointer = NULL; \
            }
 
#endif // MOOTOOLS_USE_NEW_AND_DELETE
#endif // !defined(CXMEMORYMACROS_INCLUDE_H)