x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
segment_manager_helper.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\interprocess\detail\segment_manager_helper.hpp
旋转
特效
属性
历史版本
////////////////////////////////////////////////////////////////////////////// // // (C) Copyright Ion Gaztanaga 2005-2008. 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_SEGMENT_MANAGER_BASE_HPP #define BOOST_INTERPROCESS_SEGMENT_MANAGER_BASE_HPP #if (defined _MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif #include
#include
#include
#include
#include
#include
#include
#include
//std::size_t #include
//char_traits #include
//std::nothrow #include
//std::pair #ifndef BOOST_NO_EXCEPTIONS #include
#endif //!\file //!Describes the object placed in a memory segment that provides //!named object allocation capabilities. namespace boost{ namespace interprocess{ template
class segment_manager_base; //!An integer that describes the type of the //!instance constructed in memory enum instance_type { anonymous_type, named_type, unique_type, max_allocation_type }; namespace detail{ template
class mem_algo_deallocator { void * m_ptr; MemoryAlgorithm & m_algo; public: mem_algo_deallocator(void *ptr, MemoryAlgorithm &algo) : m_ptr(ptr), m_algo(algo) {} void release() { m_ptr = 0; } ~mem_algo_deallocator() { if(m_ptr) m_algo.deallocate(m_ptr); } }; /// @cond struct block_header { std::size_t m_value_bytes; unsigned short m_num_char; unsigned char m_value_alignment; unsigned char m_alloc_type_sizeof_char; block_header(std::size_t value_bytes ,std::size_t value_alignment ,std::size_t allocation_type ,std::size_t sizeof_char ,std::size_t num_char ) : m_value_bytes(value_bytes) , m_num_char(num_char) , m_value_alignment(value_alignment) , m_alloc_type_sizeof_char ( ((unsigned char)allocation_type << 5u) | ((unsigned char)sizeof_char & 0x1F) ) {}; template
block_header &operator= (const T& ) { return *this; } std::size_t total_size() const { if(allocation_type() != anonymous_type){ return name_offset() + (m_num_char+1)*sizeof_char(); } else{ return value_offset() + m_value_bytes; } } std::size_t value_bytes() const { return m_value_bytes; } template
std::size_t total_size_with_header() const { return get_rounded_size ( sizeof(Header) , detail::alignment_of
::value) + total_size(); } std::size_t allocation_type() const { return (m_alloc_type_sizeof_char >> 5u)&(unsigned char)0x7; } std::size_t sizeof_char() const { return m_alloc_type_sizeof_char & (unsigned char)0x1F; } template
CharType *name() const { return reinterpret_cast
(detail::char_ptr_cast(this) + name_offset()); } std::size_t name_length() const { return m_num_char; } std::size_t name_offset() const { return value_offset() + get_rounded_size(m_value_bytes, sizeof_char()); } void *value() const { return detail::char_ptr_cast(this) + value_offset(); } std::size_t value_offset() const { return get_rounded_size(sizeof(block_header), m_value_alignment); } template
bool less_comp(const block_header &b) const { return m_num_char < b.m_num_char || (m_num_char < b.m_num_char && std::char_traits
::compare (name
(), b.name
(), m_num_char) < 0); } template
bool equal_comp(const block_header &b) const { return m_num_char == b.m_num_char && std::char_traits
::compare (name
(), b.name
(), m_num_char) == 0; } template
static block_header *block_header_from_value(T *value) { return block_header_from_value(value, sizeof(T), detail::alignment_of
::value); } static block_header *block_header_from_value(const void *value, std::size_t sz, std::size_t algn) { block_header * hdr = reinterpret_cast
(detail::char_ptr_cast(value) - get_rounded_size(sizeof(block_header), algn)); (void)sz; //Some sanity checks assert(hdr->m_value_alignment == algn); assert(hdr->m_value_bytes % sz == 0); return hdr; } template
static block_header *from_first_header(Header *header) { block_header * hdr = reinterpret_cast
(detail::char_ptr_cast(header) + get_rounded_size(sizeof(Header), detail::alignment_of
::value)); //Some sanity checks return hdr; } template
static Header *to_first_header(block_header *bheader) { Header * hdr = reinterpret_cast
(detail::char_ptr_cast(bheader) - get_rounded_size(sizeof(Header), detail::alignment_of
::value)); //Some sanity checks return hdr; } }; inline void array_construct(void *mem, std::size_t num, detail::in_place_interface &table) { //Try constructors std::size_t constructed = 0; BOOST_TRY{ table.construct_n(mem, num, constructed); } //If there is an exception call destructors and erase index node BOOST_CATCH(...){ std::size_t destroyed = 0; table.destroy_n(mem, constructed, destroyed); BOOST_RETHROW } BOOST_CATCH_END } //Anti-exception node eraser template
class value_eraser { public: value_eraser(Cont & cont, typename Cont::iterator it) : m_cont(cont), m_index_it(it), m_erase(true){} ~value_eraser() { if(m_erase) m_cont.erase(m_index_it); } void release() { m_erase = false; } private: Cont &m_cont; typename Cont::iterator m_index_it; bool m_erase; }; template
struct intrusive_compare_key { typedef CharT char_type; intrusive_compare_key(const CharT *str, std::size_t len) : mp_str(str), m_len(len) {} const CharT * mp_str; std::size_t m_len; }; //!This struct indicates an anonymous object creation //!allocation template
class instance_t { instance_t(){} }; template
struct char_if_void { typedef T type; }; template<> struct char_if_void
{ typedef char type; }; typedef instance_t
anonymous_instance_t; typedef instance_t
unique_instance_t; template
struct intrusive_value_type_impl : public Hook { private: //Non-copyable intrusive_value_type_impl(const intrusive_value_type_impl &); intrusive_value_type_impl& operator=(const intrusive_value_type_impl &); public: typedef CharType char_type; intrusive_value_type_impl(){} enum { BlockHdrAlignment = detail::alignment_of
::value }; block_header *get_block_header() const { return (block_header *)(detail::char_ptr_cast(this) + get_rounded_size(sizeof(*this), BlockHdrAlignment)); } bool operator <(const intrusive_value_type_impl
& other) const { return (this->get_block_header())->template less_comp
(*other.get_block_header()); } bool operator ==(const intrusive_value_type_impl
& other) const { return (this->get_block_header())->template equal_comp
(*other.get_block_header()); } static intrusive_value_type_impl *get_intrusive_value_type(block_header *hdr) { return (intrusive_value_type_impl *)(detail::char_ptr_cast(hdr) - get_rounded_size(sizeof(intrusive_value_type_impl), BlockHdrAlignment)); } CharType *name() const { return get_block_header()->template name
(); } std::size_t name_length() const { return get_block_header()->name_length(); } void *value() const { return get_block_header()->value(); } }; template
class char_ptr_holder { public: char_ptr_holder(const CharType *name) : m_name(name) {} char_ptr_holder(const detail::anonymous_instance_t *) : m_name((CharType*)0) {} char_ptr_holder(const detail::unique_instance_t *) : m_name((CharType*)-1) {} operator const CharType *() { return m_name; } private: const CharType *m_name; }; //!The key of the the named allocation information index. Stores an offset pointer //!to a null terminated string and the length of the string to speed up sorting template
struct index_key { typedef typename detail:: pointer_to_other
::type const_char_ptr_t; typedef CharT char_type; private: //Offset pointer to the object's name const_char_ptr_t mp_str; //Length of the name buffer (null NOT included) std::size_t m_len; public: //!Constructor of the key index_key (const char_type *name, std::size_t length) : mp_str(name), m_len(length) {} //!Less than function for index ordering bool operator < (const index_key & right) const { return (m_len < right.m_len) || (m_len == right.m_len && std::char_traits
::compare (detail::get_pointer(mp_str) ,detail::get_pointer(right.mp_str), m_len) < 0); } //!Equal to function for index ordering bool operator == (const index_key & right) const { return m_len == right.m_len && std::char_traits
::compare (detail::get_pointer(mp_str), detail::get_pointer(right.mp_str), m_len) == 0; } void name(const CharT *name) { mp_str = name; } void name_length(std::size_t len) { m_len = len; } const CharT *name() const { return detail::get_pointer(mp_str); } std::size_t name_length() const { return m_len; } }; //!The index_data stores a pointer to a buffer and the element count needed //!to know how many destructors must be called when calling destroy template
struct index_data { typedef VoidPointer void_pointer; void_pointer m_ptr; index_data(void *ptr) : m_ptr(ptr){} void *value() const { return (void*)detail::get_pointer(m_ptr); } }; template
struct segment_manager_base_type { typedef segment_manager_base
type; }; template
struct index_config { typedef typename MemoryAlgorithm::void_pointer void_pointer; typedef CharT char_type; typedef detail::index_key
key_type; typedef detail::index_data
mapped_type; typedef typename segment_manager_base_type
::type segment_manager_base; template
struct intrusive_value_type { typedef detail::intrusive_value_type_impl
type; }; typedef intrusive_compare_key
intrusive_compare_key_type; }; template
class segment_manager_iterator_value_adaptor { typedef typename Iterator::value_type iterator_val_t; typedef typename iterator_val_t::char_type char_type; public: segment_manager_iterator_value_adaptor(const typename Iterator::value_type &val) : m_val(&val) {} const char_type *name() const { return m_val->name(); } std::size_t name_length() const { return m_val->name_length(); } const void *value() const { return m_val->value(); } const typename Iterator::value_type *m_val; }; template
class segment_manager_iterator_value_adaptor
{ typedef typename Iterator::value_type iterator_val_t; typedef typename iterator_val_t::first_type first_type; typedef typename iterator_val_t::second_type second_type; typedef typename first_type::char_type char_type; public: segment_manager_iterator_value_adaptor(const typename Iterator::value_type &val) : m_val(&val) {} const char_type *name() const { return m_val->first.name(); } std::size_t name_length() const { return m_val->first.name_length(); } const void *value() const { return reinterpret_cast
(detail::get_pointer(m_val->second.m_ptr))->value(); } const typename Iterator::value_type *m_val; }; template
struct segment_manager_iterator_transform : std::unary_function< typename Iterator::value_type , segment_manager_iterator_value_adaptor
> { typedef segment_manager_iterator_value_adaptor
result_type; result_type operator()(const typename Iterator::value_type &arg) const { return result_type(arg); } }; } //namespace detail { }} //namespace boost { namespace interprocess #include
#endif //#ifndef BOOST_INTERPROCESS_SEGMENT_MANAGER_BASE_HPP
segment_manager_helper.hpp
网页地址
文件地址
上一页
23/29
下一页
下载
( 14 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.