////////////////////////////////////////////////////////////////////////////// | |
// | |
// (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/container for documentation. | |
// | |
////////////////////////////////////////////////////////////////////////////// | |
#ifndef BOOST_CONTAINERS_DETAIL_UTILITIES_HPP | |
#define BOOST_CONTAINERS_DETAIL_UTILITIES_HPP | |
#include "config_begin.hpp" | |
#include <cstdio> | |
#include <boost/type_traits/is_fundamental.hpp> | |
#include <boost/type_traits/is_pointer.hpp> | |
#include <boost/type_traits/is_enum.hpp> | |
#include <boost/type_traits/is_member_pointer.hpp> | |
#include INCLUDE_BOOST_CONTAINER_MOVE_HPP | |
#include INCLUDE_BOOST_CONTAINER_DETAIL_MPL_HPP | |
#include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP | |
#include <algorithm> | |
namespace boost { | |
namespace container { | |
namespace containers_detail { | |
template<class T> | |
const T &max_value(const T &a, const T &b) | |
{ return a > b ? a : b; } | |
template<class T> | |
const T &min_value(const T &a, const T &b) | |
{ return a < b ? a : b; } | |
template <class SizeType> | |
SizeType | |
get_next_capacity(const SizeType max_size | |
,const SizeType capacity | |
,const SizeType n) | |
{ | |
// if (n > max_size - capacity) | |
// throw std::length_error("get_next_capacity"); | |
const SizeType m3 = max_size/3; | |
if (capacity < m3) | |
return capacity + max_value(3*(capacity+1)/5, n); | |
if (capacity < m3*2) | |
return capacity + max_value((capacity+1)/2, n); | |
return max_size; | |
} | |
template<class SmartPtr> | |
struct smart_ptr_type | |
{ | |
typedef typename SmartPtr::value_type value_type; | |
typedef value_type *pointer; | |
static pointer get (const SmartPtr &smartptr) | |
{ return smartptr.get();} | |
}; | |
template<class T> | |
struct smart_ptr_type<T*> | |
{ | |
typedef T value_type; | |
typedef value_type *pointer; | |
static pointer get (pointer ptr) | |
{ return ptr;} | |
}; | |
//!Overload for smart pointers to avoid ADL problems with get_pointer | |
template<class Ptr> | |
inline typename smart_ptr_type<Ptr>::pointer | |
get_pointer(const Ptr &ptr) | |
{ return smart_ptr_type<Ptr>::get(ptr); } | |
//!To avoid ADL problems with swap | |
template <class T> | |
inline void do_swap(T& x, T& y) | |
{ | |
using std::swap; | |
swap(x, y); | |
} | |
//Rounds "orig_size" by excess to round_to bytes | |
inline std::size_t get_rounded_size(std::size_t orig_size, std::size_t round_to) | |
{ | |
return ((orig_size-1)/round_to+1)*round_to; | |
} | |
template <std::size_t OrigSize, std::size_t RoundTo> | |
struct ct_rounded_size | |
{ | |
enum { value = ((OrigSize-1)/RoundTo+1)*RoundTo }; | |
}; | |
template <class _TypeT> | |
struct __rw_is_enum | |
{ | |
struct _C_no { }; | |
struct _C_yes { int _C_dummy [2]; }; | |
struct _C_indirect { | |
// prevent classes with user-defined conversions from matching | |
// use double to prevent float->int gcc conversion warnings | |
_C_indirect (double); | |
}; | |
// nested struct gets rid of bogus gcc errors | |
struct _C_nest { | |
// supply first argument to prevent HP aCC warnings | |
static _C_no _C_is (int, ...); | |
static _C_yes _C_is (int, _C_indirect); | |
static _TypeT _C_make_T (); | |
}; | |
enum { | |
_C_val = sizeof (_C_yes) | |
== sizeof (_C_nest::_C_is (0, _C_nest::_C_make_T ())) | |
&& !::boost::is_fundamental<_TypeT>::value | |
}; | |
}; | |
template<class T> | |
struct move_const_ref_type | |
: if_c | |
< ::boost::is_fundamental<T>::value || ::boost::is_pointer<T>::value || | |
::boost::is_member_pointer<T>::value || ::boost::is_enum<T>::value | |
,const T & | |
,BOOST_MOVE_MACRO_CATCH_CONST_RLVALUE(T) | |
> | |
{}; | |
} //namespace containers_detail { | |
} //namespace container { | |
} //namespace boost { | |
#include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP | |
#endif //#ifndef BOOST_CONTAINERS_DETAIL_UTILITIES_HPP |