memory.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/basic.h>
#include <ogdf/basic/memory/MallocMemoryAllocator.h>
#include <ogdf/basic/memory/PoolMemoryAllocator.h>
 
#include <cstddef>
 
namespace ogdf {
 
 
#define OGDF_MM(Alloc)                                              \
public:                                                             \
    static void* operator new(size_t nBytes) {                      \
        if (OGDF_LIKELY(Alloc::checkSize(nBytes)))                  \
            return Alloc::allocate(nBytes);                         \
        else                                                        \
            return ogdf::MallocMemoryAllocator::allocate(nBytes);   \
    }                                                               \
                                                                    \
    static void operator delete(void* p, size_t nBytes) {           \
        if (OGDF_LIKELY(p != 0)) {                                  \
            if (OGDF_LIKELY(Alloc::checkSize(nBytes)))              \
                Alloc::deallocate(nBytes, p);                       \
            else                                                    \
                ogdf::MallocMemoryAllocator::deallocate(nBytes, p); \
        }                                                           \
    }                                                               \
    static void* operator new(size_t, void* p) { return p; }        \
    static void operator delete(void*, void*) { }
 
#ifdef OGDF_MEMORY_MALLOC_TS
#   define OGDF_ALLOCATOR ogdf::MallocMemoryAllocator
#else
#   define OGDF_ALLOCATOR ogdf::PoolMemoryAllocator
#endif
 
#define OGDF_NEW_DELETE OGDF_MM(OGDF_ALLOCATOR)
 
#define OGDF_MALLOC_NEW_DELETE OGDF_MM(ogdf::MallocMemoryAllocator)
 
template<class T>
struct OGDFAllocator {
    using value_type = T;
 
    OGDFAllocator() noexcept = default;
 
    template<class U>
    OGDFAllocator(const OGDFAllocator<U>&) noexcept { }
 
    template<class U>
    bool operator==(const OGDFAllocator<U>&) const noexcept {
        return true;
    }
 
    template<class U>
    bool operator!=(const OGDFAllocator<U>&) const noexcept {
        return false;
    }
 
    T* allocate(const size_t n) const {
        const size_t s = n * sizeof(T);
        if (OGDF_LIKELY(OGDF_ALLOCATOR::checkSize(s))) {
            return static_cast<T*>(OGDF_ALLOCATOR::allocate(s));
        } else {
            return static_cast<T*>(ogdf::MallocMemoryAllocator::allocate(s));
        }
    }
 
    void deallocate(T* const p, size_t n) const noexcept {
        if (OGDF_LIKELY(p != nullptr)) {
            const size_t s = n * sizeof(T);
            if (OGDF_LIKELY(OGDF_ALLOCATOR::checkSize(s))) {
                OGDF_ALLOCATOR::deallocate(s, p);
            } else {
                ogdf::MallocMemoryAllocator::deallocate(s, p);
            }
        }
    }
};
 
 
}