BentleyAllocator.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once


#include "Bentley.h"
#include <memory>

#define DEFINE_BENTLEY_NEW_DELETE_OPERATORS\
    void* operator new(size_t size) { return bentleyAllocator_new(size); }\
    void operator delete(void *rawMemory, size_t size) { bentleyAllocator_delete(rawMemory, size); }


#if !defined (BENTLEYALLOCATOR_EXPORT)
#define BENTLEYALLOCATOR_EXPORT  IMPORT_ATTRIBUTE
#endif

extern "C" BENTLEYALLOCATOR_EXPORT void* bentleyAllocator_new (size_t);
extern "C" BENTLEYALLOCATOR_EXPORT void  bentleyAllocator_delete (void*, size_t);
extern "C" BENTLEYALLOCATOR_EXPORT void* bentleyAllocator_malloc (size_t);
extern "C" BENTLEYALLOCATOR_EXPORT void* bentleyAllocator_realloc (void*, size_t);
extern "C" BENTLEYALLOCATOR_EXPORT void  bentleyAllocator_free (void*, size_t);
extern "C" BENTLEYALLOCATOR_EXPORT void* bentleyAllocator_getNullRefBuffer ();
extern "C" BENTLEYALLOCATOR_EXPORT void  bentleyAllocator_enableLowFragmentationCRTHeap ();

BEGIN_BENTLEY_NAMESPACE


/*=================================================================================**/
struct          BeVirtualMemory
{
enum AllocationType {TopDown=1, Commit=2, Reserve=4, CommitTopDown=Commit|TopDown};
enum Protection     {ReadWrite=1,ReadOnly=2};
enum FreeType       {Release=1, Decommit=2};

    BENTLEYDLL_EXPORT static void* Alloc (void*, size_t numBytes, AllocationType, Protection);

    BENTLEYDLL_EXPORT static BentleyStatus Protect (Protection*, void*, size_t numBytes, Protection);

    BENTLEYDLL_EXPORT static BentleyStatus Free (void*, size_t numBytes, FreeType);    

    BENTLEYDLL_EXPORT static Int32 GetPageSize();

}; // BeVirtualMemory

/*=================================================================================**/
template <class _Ty> class BentleyAllocator
        {
public:
        typedef _Ty         value_type;
        typedef _Ty*        pointer;
        typedef _Ty&        reference;
        typedef _Ty const*  const_pointer;
        typedef _Ty const&  const_reference;
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;

        template<class _Other>  struct rebind
                {       // convert an allocator<_Ty> to an allocator <_Other>
                typedef BentleyAllocator<_Other> other;
                };

        pointer address(reference _Val) const
                {       // return address of mutable _Val
                return (&_Val);
                }

        const_pointer address(const_reference _Val) const
                {       // return address of nonmutable _Val
                return (&_Val);
                }

        BentleyAllocator()
                {       // construct default allocator (do nothing)
                }

        BentleyAllocator(const BentleyAllocator<_Ty>&)
                {       // construct by copying (do nothing)
                }

        template<class _Other>
                BentleyAllocator(const BentleyAllocator<_Other>&)
                {       // construct from a related allocator (do nothing)
                }

        template<class _Other>
                BentleyAllocator<_Ty>& operator=(const BentleyAllocator<_Other>&)
                {       // assign from a related allocator (do nothing)
                return (*this);
                }

        void deallocate(pointer _Ptr, size_type _Size)
                {       // deallocate object at _Ptr, ignore size
                bentleyAllocator_free (_Ptr, _Size * sizeof (_Ty));
                }

        pointer allocate(size_type _Count)
                {       // allocate array of _Count elements
                return (pointer) bentleyAllocator_malloc (_Count * sizeof (_Ty));
                }

        pointer allocate(size_type _Count, typename std::allocator<void>::const_pointer)
                {       // allocate array of _Count elements, ignore hint
                return (allocate(_Count));
                }

        void construct(pointer _Ptr, const _Ty& _Val)
                {       // construct object at _Ptr with value _Val
                new((void*)_Ptr)_Ty(_Val);
                }

        void destroy(pointer _Ptr)
                {       // destroy object at _Ptr
                _Ptr->~_Ty();
                }

        size_type max_size() const
                {       // estimate maximum array size
                size_type _Count = (size_type)(-1) / sizeof (_Ty);
                return (0 < _Count ? _Count : 1);
                }
        };


template<class _Ty, class _Other>
        bool operator== (const BentleyAllocator<_Ty>&, const BentleyAllocator<_Other>&)
        {       // test for allocator equality (always true)
        return true;
        }

template <class _Ty, class _Other>
        bool operator!= (const BentleyAllocator<_Ty>&, const BentleyAllocator<_Other>&)
        {       // test for allocator inequality (always false)
        return false;
        }


END_BENTLEY_NAMESPACE