////////////////////////////////////////////////////////////////////////////// | |
// | |
// (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_OFFSET_PTR_HPP | |
#define BOOST_OFFSET_PTR_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/interprocess_fwd.hpp> | |
#include <boost/interprocess/detail/utilities.hpp> | |
#include <boost/interprocess/detail/cast_tags.hpp> | |
#include <boost/interprocess/detail/mpl.hpp> | |
#include <boost/pointer_cast.hpp> | |
#include <boost/assert.hpp> | |
#include <boost/assert.hpp> | |
#include <ostream> | |
#include <istream> | |
#include <iterator> | |
//!\file | |
//!Describes a smart pointer that stores the offset between this pointer and | |
//!target pointee, called offset_ptr. | |
namespace boost { | |
//Predeclarations | |
template <class T> | |
struct has_trivial_constructor; | |
template <class T> | |
struct has_trivial_destructor; | |
namespace interprocess { | |
//!A smart pointer that stores the offset between between the pointer and the | |
//!the object it points. This allows offset allows special properties, since | |
//!the pointer is independent from the address address of the pointee, if the | |
//!pointer and the pointee are still separated by the same offset. This feature | |
//!converts offset_ptr in a smart pointer that can be placed in shared memory and | |
//!memory mapped files mapped in different addresses in every process. | |
template <class PointedType> | |
class offset_ptr | |
{ | |
/// @cond | |
typedef offset_ptr<PointedType> self_t; | |
void unspecified_bool_type_func() const {} | |
typedef void (self_t::*unspecified_bool_type)() const; | |
#if defined(_MSC_VER) && (_MSC_VER >= 1400) | |
__declspec(noinline) //this workaround is needed for msvc > 8.0 | |
#endif | |
void set_offset(const PointedType *ptr) | |
{ | |
//offset == 1 && ptr != 0 is not legal for this pointer | |
if(!ptr){ | |
internal.m_offset = 1; | |
} | |
else{ | |
internal.m_offset = (const char*)ptr - (const char*)(this); | |
BOOST_ASSERT(internal.m_offset != 1); | |
} | |
} | |
#if defined(_MSC_VER) && (_MSC_VER >= 1400) | |
__declspec(noinline) //this workaround is needed for msvc-8.0 and msvc-9.0 | |
#endif | |
void* get_pointer() const | |
{ return (internal.m_offset == 1) ? 0 : (const_cast<char*>(reinterpret_cast<const char*>(this)) + internal.m_offset); } | |
void inc_offset(std::ptrdiff_t bytes) | |
{ internal.m_offset += bytes; } | |
void dec_offset(std::ptrdiff_t bytes) | |
{ internal.m_offset -= bytes; } | |
union internal_type{ | |
std::ptrdiff_t m_offset; //Distance between this object and pointed address | |
PointedType *aliasing_helper; | |
} internal; | |
/// @endcond | |
public: | |
typedef PointedType * pointer; | |
typedef typename detail:: | |
add_reference<PointedType>::type reference; | |
typedef PointedType value_type; | |
typedef std::ptrdiff_t difference_type; | |
typedef std::random_access_iterator_tag iterator_category; | |
public: //Public Functions | |
//!Constructor from raw pointer (allows "0" pointer conversion). | |
//!Never throws. | |
offset_ptr(pointer ptr = 0) { this->set_offset(ptr); } | |
//!Constructor from other pointer. | |
//!Never throws. | |
template <class T> | |
offset_ptr(T *ptr) | |
{ pointer p (ptr); (void)p; this->set_offset(p); } | |
//!Constructor from other offset_ptr | |
//!Never throws. | |
offset_ptr(const offset_ptr& ptr) | |
{ this->set_offset(ptr.get()); } | |
//!Constructor from other offset_ptr. If pointers of pointee types are | |
//!convertible, offset_ptrs will be convertibles. Never throws. | |
template<class T2> | |
offset_ptr(const offset_ptr<T2> &ptr) | |
{ pointer p(ptr.get()); (void)p; this->set_offset(p); } | |
//!Emulates static_cast operator. | |
//!Never throws. | |
template<class Y> | |
offset_ptr(const offset_ptr<Y> & r, detail::static_cast_tag) | |
{ this->set_offset(static_cast<PointedType*>(r.get())); } | |
//!Emulates const_cast operator. | |
//!Never throws. | |
template<class Y> | |
offset_ptr(const offset_ptr<Y> & r, detail::const_cast_tag) | |
{ this->set_offset(const_cast<PointedType*>(r.get())); } | |
//!Emulates dynamic_cast operator. | |
//!Never throws. | |
template<class Y> | |
offset_ptr(const offset_ptr<Y> & r, detail::dynamic_cast_tag) | |
{ this->set_offset(dynamic_cast<PointedType*>(r.get())); } | |
//!Emulates reinterpret_cast operator. | |
//!Never throws. | |
template<class Y> | |
offset_ptr(const offset_ptr<Y> & r, detail::reinterpret_cast_tag) | |
{ this->set_offset(reinterpret_cast<PointedType*>(r.get())); } | |
//!Obtains raw pointer from offset. | |
//!Never throws. | |
pointer get()const | |
{ return static_cast<pointer>(this->get_pointer()); } | |
std::ptrdiff_t get_offset() const | |
{ return internal.m_offset; } | |
//!Pointer-like -> operator. It can return 0 pointer. | |
//!Never throws. | |
pointer operator->() const | |
{ return this->get(); } | |
//!Dereferencing operator, if it is a null offset_ptr behavior | |
//! is undefined. Never throws. | |
reference operator* () const | |
{ | |
pointer p = this->get(); | |
reference r = *p; | |
return r; | |
} | |
//!Indexing operator. | |
//!Never throws. | |
reference operator[](std::ptrdiff_t idx) const | |
{ return this->get()[idx]; } | |
//!Assignment from pointer (saves extra conversion). | |
//!Never throws. | |
offset_ptr& operator= (pointer from) | |
{ this->set_offset(from); return *this; } | |
//!Assignment from other offset_ptr. | |
//!Never throws. | |
offset_ptr& operator= (const offset_ptr & pt) | |
{ pointer p(pt.get()); (void)p; this->set_offset(p); return *this; } | |
//!Assignment from related offset_ptr. If pointers of pointee types | |
//! are assignable, offset_ptrs will be assignable. Never throws. | |
template <class T2> | |
offset_ptr& operator= (const offset_ptr<T2> & pt) | |
{ pointer p(pt.get()); this->set_offset(p); return *this; } | |
//!offset_ptr + std::ptrdiff_t. | |
//!Never throws. | |
offset_ptr operator+ (std::ptrdiff_t offset) const | |
{ return offset_ptr(this->get()+offset); } | |
//!offset_ptr - std::ptrdiff_t. | |
//!Never throws. | |
offset_ptr operator- (std::ptrdiff_t offset) const | |
{ return offset_ptr(this->get()-offset); } | |
//!offset_ptr += std::ptrdiff_t. | |
//!Never throws. | |
offset_ptr &operator+= (std::ptrdiff_t offset) | |
{ this->inc_offset(offset * sizeof (PointedType)); return *this; } | |
//!offset_ptr -= std::ptrdiff_t. | |
//!Never throws. | |
offset_ptr &operator-= (std::ptrdiff_t offset) | |
{ this->dec_offset(offset * sizeof (PointedType)); return *this; } | |
//!++offset_ptr. | |
//!Never throws. | |
offset_ptr& operator++ (void) | |
{ this->inc_offset(sizeof (PointedType)); return *this; } | |
//!offset_ptr++. | |
//!Never throws. | |
offset_ptr operator++ (int) | |
{ offset_ptr temp(*this); ++*this; return temp; } | |
//!--offset_ptr. | |
//!Never throws. | |
offset_ptr& operator-- (void) | |
{ this->dec_offset(sizeof (PointedType)); return *this; } | |
//!offset_ptr--. | |
//!Never throws. | |
offset_ptr operator-- (int) | |
{ offset_ptr temp(*this); --*this; return temp; } | |
//!safe bool conversion operator. | |
//!Never throws. | |
operator unspecified_bool_type() const | |
{ return this->get()? &self_t::unspecified_bool_type_func : 0; } | |
//!Not operator. Not needed in theory, but improves portability. | |
//!Never throws | |
bool operator! () const | |
{ return this->get() == 0; } | |
/* | |
friend void swap (offset_ptr &pt, offset_ptr &pt2) | |
{ | |
value_type *ptr = pt.get(); | |
pt = pt2; | |
pt2 = ptr; | |
} | |
*/ | |
}; | |
//!offset_ptr<T1> == offset_ptr<T2>. | |
//!Never throws. | |
template<class T1, class T2> | |
inline bool operator== (const offset_ptr<T1> &pt1, | |
const offset_ptr<T2> &pt2) | |
{ return pt1.get() == pt2.get(); } | |
//!offset_ptr<T1> != offset_ptr<T2>. | |
//!Never throws. | |
template<class T1, class T2> | |
inline bool operator!= (const offset_ptr<T1> &pt1, | |
const offset_ptr<T2> &pt2) | |
{ return pt1.get() != pt2.get(); } | |
//!offset_ptr<T1> < offset_ptr<T2>. | |
//!Never throws. | |
template<class T1, class T2> | |
inline bool operator< (const offset_ptr<T1> &pt1, | |
const offset_ptr<T2> &pt2) | |
{ return pt1.get() < pt2.get(); } | |
//!offset_ptr<T1> <= offset_ptr<T2>. | |
//!Never throws. | |
template<class T1, class T2> | |
inline bool operator<= (const offset_ptr<T1> &pt1, | |
const offset_ptr<T2> &pt2) | |
{ return pt1.get() <= pt2.get(); } | |
//!offset_ptr<T1> > offset_ptr<T2>. | |
//!Never throws. | |
template<class T1, class T2> | |
inline bool operator> (const offset_ptr<T1> &pt1, | |
const offset_ptr<T2> &pt2) | |
{ return pt1.get() > pt2.get(); } | |
//!offset_ptr<T1> >= offset_ptr<T2>. | |
//!Never throws. | |
template<class T1, class T2> | |
inline bool operator>= (const offset_ptr<T1> &pt1, | |
const offset_ptr<T2> &pt2) | |
{ return pt1.get() >= pt2.get(); } | |
//!operator<< | |
//!for offset ptr | |
template<class E, class T, class Y> | |
inline std::basic_ostream<E, T> & operator<< | |
(std::basic_ostream<E, T> & os, offset_ptr<Y> const & p) | |
{ return os << p.get_offset(); } | |
//!operator>> | |
//!for offset ptr | |
template<class E, class T, class Y> | |
inline std::basic_istream<E, T> & operator>> | |
(std::basic_istream<E, T> & is, offset_ptr<Y> & p) | |
{ return is >> p.get_offset(); } | |
//!std::ptrdiff_t + offset_ptr | |
//!operation | |
template<class T> | |
inline offset_ptr<T> operator+(std::ptrdiff_t diff, const offset_ptr<T>& right) | |
{ return right + diff; } | |
//!offset_ptr - offset_ptr | |
//!operation | |
template<class T, class T2> | |
inline std::ptrdiff_t operator- (const offset_ptr<T> &pt, const offset_ptr<T2> &pt2) | |
{ return pt.get()- pt2.get(); } | |
//!swap specialization | |
//!for offset_ptr | |
template<class T> | |
inline void swap (boost::interprocess::offset_ptr<T> &pt, | |
boost::interprocess::offset_ptr<T> &pt2) | |
{ | |
typename offset_ptr<T>::value_type *ptr = pt.get(); | |
pt = pt2; | |
pt2 = ptr; | |
} | |
//!Simulation of static_cast between pointers. Never throws. | |
template<class T, class U> | |
inline boost::interprocess::offset_ptr<T> | |
static_pointer_cast(const boost::interprocess::offset_ptr<U> & r) | |
{ | |
return boost::interprocess::offset_ptr<T> | |
(r, boost::interprocess::detail::static_cast_tag()); | |
} | |
//!Simulation of const_cast between pointers. Never throws. | |
template<class T, class U> | |
inline boost::interprocess::offset_ptr<T> | |
const_pointer_cast(const boost::interprocess::offset_ptr<U> & r) | |
{ | |
return boost::interprocess::offset_ptr<T> | |
(r, boost::interprocess::detail::const_cast_tag()); | |
} | |
//!Simulation of dynamic_cast between pointers. Never throws. | |
template<class T, class U> | |
inline boost::interprocess::offset_ptr<T> | |
dynamic_pointer_cast(const boost::interprocess::offset_ptr<U> & r) | |
{ | |
return boost::interprocess::offset_ptr<T> | |
(r, boost::interprocess::detail::dynamic_cast_tag()); | |
} | |
//!Simulation of reinterpret_cast between pointers. Never throws. | |
template<class T, class U> | |
inline boost::interprocess::offset_ptr<T> | |
reinterpret_pointer_cast(const boost::interprocess::offset_ptr<U> & r) | |
{ | |
return boost::interprocess::offset_ptr<T> | |
(r, boost::interprocess::detail::reinterpret_cast_tag()); | |
} | |
} //namespace interprocess { | |
/// @cond | |
//!has_trivial_constructor<> == true_type specialization for optimizations | |
template <class T> | |
struct has_trivial_constructor< boost::interprocess::offset_ptr<T> > | |
{ | |
enum { value = true }; | |
}; | |
///has_trivial_destructor<> == true_type specialization for optimizations | |
template <class T> | |
struct has_trivial_destructor< boost::interprocess::offset_ptr<T> > | |
{ | |
enum { value = true }; | |
}; | |
//#if !defined(_MSC_VER) || (_MSC_VER >= 1400) | |
namespace interprocess { | |
//#endif | |
//!get_pointer() enables boost::mem_fn to recognize offset_ptr. | |
//!Never throws. | |
template<class T> | |
inline T * get_pointer(boost::interprocess::offset_ptr<T> const & p) | |
{ return p.get(); } | |
//#if !defined(_MSC_VER) || (_MSC_VER >= 1400) | |
} //namespace interprocess | |
//#endif | |
/// @endcond | |
} //namespace boost { | |
/// @cond | |
namespace boost{ | |
//This is to support embedding a bit in the pointer | |
//for intrusive containers, saving space | |
namespace intrusive { | |
//Predeclaration to avoid including header | |
template<class VoidPointer, std::size_t N> | |
struct max_pointer_plus_bits; | |
template<std::size_t Alignment> | |
struct max_pointer_plus_bits<boost::interprocess::offset_ptr<void>, Alignment> | |
{ | |
//The offset ptr can embed one bit less than the alignment since it | |
//uses offset == 1 to store the null pointer. | |
static const std::size_t value = ::boost::interprocess::detail::ls_zeros<Alignment>::value - 1; | |
}; | |
//Predeclaration | |
template<class Pointer, std::size_t NumBits> | |
struct pointer_plus_bits; | |
template<class T, std::size_t NumBits> | |
struct pointer_plus_bits<boost::interprocess::offset_ptr<T>, NumBits> | |
{ | |
typedef boost::interprocess::offset_ptr<T> pointer; | |
//Bits are stored in the lower bits of the pointer except the LSB, | |
//because this bit is used to represent the null pointer. | |
static const std::size_t Mask = ((std::size_t(1) << NumBits)-1)<<1u; | |
static pointer get_pointer(const pointer &n) | |
{ return reinterpret_cast<T*>(std::size_t(n.get()) & ~std::size_t(Mask)); } | |
static void set_pointer(pointer &n, pointer p) | |
{ | |
std::size_t pint = std::size_t(p.get()); | |
BOOST_ASSERT(0 == (std::size_t(pint) & Mask)); | |
n = reinterpret_cast<T*>(pint | (std::size_t(n.get()) & std::size_t(Mask))); | |
} | |
static std::size_t get_bits(const pointer &n) | |
{ return(std::size_t(n.get()) & std::size_t(Mask)) >> 1u; } | |
static void set_bits(pointer &n, std::size_t b) | |
{ | |
BOOST_ASSERT(b < (std::size_t(1) << NumBits)); | |
n = reinterpret_cast<T*>(std::size_t(get_pointer(n).get()) | (b << 1u)); | |
} | |
}; | |
} //namespace intrusive | |
} //namespace boost{ | |
/// @endcond | |
#include <boost/interprocess/detail/config_end.hpp> | |
#endif //#ifndef BOOST_OFFSET_PTR_HPP | |