| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // (C) Copyright Ion Gaztanaga 2005-2009. Distributed under the Boost |
| // Software License, Version 1.0. (See accompanying file |
| // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // See http://www.boost.org/libs/interprocess for documentation. |
| // |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| #ifndef BOOST_INTERPROCESS_MANAGED_HEAP_MEMORY_HPP |
| #define BOOST_INTERPROCESS_MANAGED_HEAP_MEMORY_HPP |
| |
| #if (defined _MSC_VER) && (_MSC_VER >= 1200) |
| # pragma once |
| #endif |
| |
| #include <boost/interprocess/detail/config_begin.hpp> |
| #include <boost/interprocess/detail/workaround.hpp> |
| #include <boost/interprocess/creation_tags.hpp> |
| #include <boost/interprocess/detail/move.hpp> |
| #include <vector> |
| #include <boost/interprocess/detail/managed_memory_impl.hpp> |
| #include <boost/detail/no_exceptions_support.hpp> |
| |
| //!\file |
| //!Describes a named heap memory allocation user class. |
| |
| namespace boost { |
| namespace interprocess { |
| |
| //!A basic heap memory named object creation class. Initializes the |
| //!heap memory segment. Inherits all basic functionality from |
| //!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/ |
| template |
| < |
| class CharType, |
| class AllocationAlgorithm, |
| template<class IndexConfig> class IndexType |
| > |
| class basic_managed_heap_memory |
| : public detail::basic_managed_memory_impl <CharType, AllocationAlgorithm, IndexType> |
| { |
| /// @cond |
| private: |
| |
| typedef detail::basic_managed_memory_impl |
| <CharType, AllocationAlgorithm, IndexType> base_t; |
| BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(basic_managed_heap_memory) |
| /// @endcond |
| |
| public: //functions |
| |
| //!Default constructor. Does nothing. |
| //!Useful in combination with move semantics |
| basic_managed_heap_memory(){} |
| |
| //!Destructor. Liberates the heap memory holding the managed data. |
| //!Never throws. |
| ~basic_managed_heap_memory() |
| { this->priv_close(); } |
| |
| //!Creates heap memory and initializes the segment manager. |
| //!This can throw. |
| basic_managed_heap_memory(std::size_t size) |
| : m_heapmem(size, char(0)) |
| { |
| if(!base_t::create_impl(&m_heapmem[0], size)){ |
| this->priv_close(); |
| throw interprocess_exception("Could not initialize heap in basic_managed_heap_memory constructor"); |
| } |
| } |
| |
| //!Moves the ownership of "moved"'s managed memory to *this. Does not throw |
| basic_managed_heap_memory(BOOST_INTERPROCESS_RV_REF(basic_managed_heap_memory) moved) |
| { this->swap(moved); } |
| |
| //!Moves the ownership of "moved"'s managed memory to *this. Does not throw |
| basic_managed_heap_memory &operator=(BOOST_INTERPROCESS_RV_REF(basic_managed_heap_memory) moved) |
| { |
| basic_managed_heap_memory tmp(boost::interprocess::move(moved)); |
| this->swap(tmp); |
| return *this; |
| } |
| |
| //!Tries to resize internal heap memory so that |
| //!we have room for more objects. |
| //!WARNING: If memory is reallocated, all the objects will |
| //!be binary-copied to the new buffer. To be able to use |
| //!this function, all pointers constructed in this buffer |
| //!must be offset pointers. Otherwise, the result is undefined. |
| //!Returns true if the growth has been successful, so you will |
| //!have some extra bytes to allocate new objects. If returns |
| //!false, the heap allocation has failed. |
| bool grow(std::size_t extra_bytes) |
| { |
| //If memory is reallocated, data will |
| //be automatically copied |
| BOOST_TRY{ |
| m_heapmem.resize(m_heapmem.size()+extra_bytes); |
| } |
| BOOST_CATCH(...){ |
| return false; |
| } |
| BOOST_CATCH_END |
| |
| //Grow always works |
| base_t::close_impl(); |
| base_t::open_impl(&m_heapmem[0], m_heapmem.size()); |
| base_t::grow(extra_bytes); |
| return true; |
| } |
| |
| //!Swaps the ownership of the managed heap memories managed by *this and other. |
| //!Never throws. |
| void swap(basic_managed_heap_memory &other) |
| { |
| base_t::swap(other); |
| m_heapmem.swap(other.m_heapmem); |
| } |
| |
| /// @cond |
| private: |
| //!Frees resources. Never throws. |
| void priv_close() |
| { |
| base_t::destroy_impl(); |
| std::vector<char>().swap(m_heapmem); |
| } |
| |
| std::vector<char> m_heapmem; |
| /// @endcond |
| }; |
| |
| |
| } //namespace interprocess { |
| } //namespace boost { |
| |
| #include <boost/interprocess/detail/config_end.hpp> |
| |
| #endif //BOOST_INTERPROCESS_MANAGED_HEAP_MEMORY_HPP |
| |