MemoryPool.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is 
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable 
// OnixS Software Services Agreement (the Agreement) and Customer end user license 
// agreements granting a non-assignable, non-transferable and non-exclusive license 
// to use the software for it's own data processing purposes under the terms defined 
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or 
// reproduction of any part of this source code or associated reference material 
// to any other location for further reproduction or redistribution, and any 
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in 
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#if defined (ONIXS_CONFLATEDUDP_ENABLE_TRACING)
#include <ostream>
#endif
 
#include <cassert>
 
#include <OnixS/CME/ConflatedUDP/Bootstrap.h>
 
ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

ONIXS_CONFLATEDUDP_EXPORTED_CLASS MemoryPool
{
    // Copies are disallowed. 
    MemoryPool(
        const MemoryPool&)
    {
    }
 
    // Assignment is disallowed. 
    MemoryPool&
    operator =(
        const MemoryPool&)
    {
        return *this;
    }
 
protected:
    MemoryPool()
    {
    }

    virtual ~MemoryPool()
    {
    }
 
public:
    virtual void release() = 0;

    virtual void* allocate(size_t) = 0;

    virtual void deallocate(void*) = 0;
 
#if defined (ONIXS_CONFLATEDUDP_ENABLE_TRACING)
    virtual void trace(std::ostream&) = 0;
#endif
};
 
// Implements STL allocator over MemoryPool. 
template
<
    class Object
>
class MemoryPoolAllocator
{
    MemoryPool* pool_;
 
public:
    typedef Object value_type;
    typedef Object* pointer;
    typedef const Object* const_pointer;
    
    typedef Object& reference;
    typedef const Object& const_reference;
    
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
 
    template
    <
        class Other
    >
    struct rebind
    {
        typedef 
        MemoryPoolAllocator<Other> 
        other;
    };
 
    MemoryPoolAllocator()
    : pool_(NULL)
    {
    }
 
    MemoryPoolAllocator(
        MemoryPool& memoryPool) 
        : pool_(&memoryPool)
    {
    }
 
    MemoryPoolAllocator(
        const MemoryPoolAllocator& other)
        : pool_(other.pool_)
    {
    }
 
    template
    <
        class Other
    >
    MemoryPoolAllocator(
        const MemoryPoolAllocator<Other>& other)
        : pool_(&other.memoryPool())
    {
    }
 
    ~MemoryPoolAllocator() 
    {
    }
 
    MemoryPool& memoryPool() const
    {
        return *pool_;
    }
 
    pointer 
    address(
        reference obj) const 
    {
        return &obj;
    }
 
    const_pointer
    address(
        const_reference x) const
    {
        return &x;
    }
 
    pointer 
    allocate(
        size_type qty) 
    {
        assert(NULL != pool_);
 
        return static_cast<pointer>
        (
            pool_->allocate
            (
                qty * sizeof(value_type)
            )
        );
    }
 
    void 
    deallocate(
        pointer block, 
        size_type) 
    {
        assert(NULL != pool_);
 
        pool_->deallocate(block);
    }
 
    void 
    construct(
        pointer block, 
        const value_type& obj) 
    { 
        new (block) value_type(obj); 
    }
 
    void 
    destroy(
        pointer obj) 
    {
        obj->~value_type();
        (void) obj;
    }
 
    size_type max_size() const 
    { 
        return 
            static_cast<size_type>(-1) / 
            sizeof(value_type);
    }
 
    MemoryPoolAllocator&
    operator =(
        const MemoryPoolAllocator& other)
    {
        pool_ = other.pool_;
 
        return *this;
    }
 
    template
    <
        class Other
    >
    MemoryPoolAllocator&
    operator =(
        const MemoryPoolAllocator<Other>& other)
    {
        pool_ = &other.memoryPool();
 
        return *this;
    }
};
 
template 
<
    class Object,
    class OtherObject
>
inline 
bool 
operator ==(
    const MemoryPoolAllocator<Object>& left, 
    const MemoryPoolAllocator<OtherObject>& right) 
{
    return (
        &left.memoryPool() == 
            &right.memoryPool()
    );
}
 
template 
<
    class Object,
    class OtherObject
>
inline 
bool 
operator !=(
    const MemoryPoolAllocator<Object>& left, 
    const MemoryPoolAllocator<OtherObject>& right) 
{
    return (
        &left.memoryPool() != 
            &right.memoryPool()
    );
}

ONIXS_CONFLATEDUDP_EXPORTED
MemoryPool*
makeMemoryPool(
    size_t, size_t, size_t, size_t);
 
ONIXS_CONFLATEDUDP_NAMESPACE_END