// 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_CMEMDH_ENABLE_TRACING) #include #endif #include #include ONIXS_CMEMDH_NAMESPACE_BEGIN /// Memory pool abstraction. /// /// Defines interface for memory block /// allocation and disposing. ONIXS_CMEMDH_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_CMEMDH_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; }; MemoryPoolAllocator() : pool_(NULL) { } MemoryPoolAllocator( MemoryPool& memoryPool) : pool_(&memoryPool) { } MemoryPoolAllocator( const MemoryPoolAllocator& other) : pool_(other.pool_) { } template < class Other > MemoryPoolAllocator( const MemoryPoolAllocator& 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 ( 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(-1) / sizeof(value_type); } MemoryPoolAllocator& operator =( const MemoryPoolAllocator& other) { pool_ = other.pool_; return *this; } template < class Other > MemoryPoolAllocator& operator =( const MemoryPoolAllocator& other) { pool_ = &other.memoryPool(); return *this; } }; template < class Object, class OtherObject > inline bool operator ==( const MemoryPoolAllocator& left, const MemoryPoolAllocator& right) { return ( &left.memoryPool() == &right.memoryPool() ); } template < class Object, class OtherObject > inline bool operator !=( const MemoryPoolAllocator& left, const MemoryPoolAllocator& right) { return ( &left.memoryPool() != &right.memoryPool() ); } /// Constructs memory pool instance /// according to given configuration. ONIXS_CMEMDH_EXPORTED MemoryPool* makeMemoryPool( size_t, size_t, size_t, size_t); ONIXS_CMEMDH_NAMESPACE_END