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

/// Memory pool abstraction. 
///
/// Defines interface for memory block 
/// allocation and disposing. 
ONIXS_CONFLATEDUDP_EXPORTED_CLASS MemoryPool
{
    // Copies are disallowed. 
    MemoryPool(
        const MemoryPool&)
    {
    }

    // Assignment is disallowed. 
    MemoryPool&
    operator =(
        const MemoryPool&)
    {
        return *this;
    }

protected:
    /// Default initialization. 
    ///
    /// Instance construction is 
    /// assumed through descendants. 
    MemoryPool()
    {
    }

    /// Destruction is through descendants.
    virtual ~MemoryPool()
    {
    }

public:
    /// Releases given instance. 
    virtual void release() = 0;

    /// Allocates memory block of given size. 
    virtual void* allocate(size_t) = 0;

    /// Releases previously allocated memory block. 
    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()
    );
}

/// Constructs a memory pool instance 
/// according to the given configuration. 
ONIXS_CONFLATEDUDP_EXPORTED
MemoryPool*
makeMemoryPool(
    size_t, size_t, size_t, size_t);

ONIXS_CONFLATEDUDP_NAMESPACE_END