boostorg/intrusive
1
0
Fork 1
mirror of https://github.com/boostorg/intrusive.git synced 2025-08-03 06:24:44 +02:00
Code Issues Packages Projects Releases Wiki Activity

Reduced include dependencies

Browse Source
This commit is contained in:
Ion Gaztañaga
2015-01-02 18:41:20 +01:00
parent 757475e59c
commit 614ce1b155
23 changed files with 406 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/boost/intrusive/avl_set.hpp
View File

@@ -268,7 +268,7 @@ class avl_set_impl
//! @copydoc ::boost::intrusive::avltree::lower_bound(const_reference) //! @copydoc ::boost::intrusive::avltree::lower_bound(const_reference)
iterator lower_bound(const_reference value); iterator lower_bound(const_reference value);
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyValueCompare) //! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyValueCompare)
template<class KeyType, class KeyValueCompare> template<class KeyType, class KeyValueCompare>
iterator lower_bound(const KeyType& key, KeyValueCompare comp); iterator lower_bound(const KeyType& key, KeyValueCompare comp);
@@ -644,7 +644,7 @@ class avl_multiset_impl
//! @copydoc ::boost::intrusive::avltree::clone_from //! @copydoc ::boost::intrusive::avltree::clone_from
template <class Cloner, class Disposer> template <class Cloner, class Disposer>
void clone_from(const avl_multiset_impl &src, Cloner cloner, Disposer disposer); void clone_from(const avl_multiset_impl &src, Cloner cloner, Disposer disposer);
#endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED #endif //#ifdef BOOST_iNTRUSIVE_DOXYGEN_INVOKED
//! @copydoc ::boost::intrusive::avltree::insert_equal(reference) //! @copydoc ::boost::intrusive::avltree::insert_equal(reference)
@@ -715,7 +715,7 @@ class avl_multiset_impl
//! @copydoc ::boost::intrusive::avltree::lower_bound(const_reference) //! @copydoc ::boost::intrusive::avltree::lower_bound(const_reference)
iterator lower_bound(const_reference value); iterator lower_bound(const_reference value);
//! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyValueCompare) //! @copydoc ::boost::intrusive::avltree::lower_bound(const KeyType&,KeyValueCompare)
template<class KeyType, class KeyValueCompare> template<class KeyType, class KeyValueCompare>
iterator lower_bound(const KeyType& key, KeyValueCompare comp); iterator lower_bound(const KeyType& key, KeyValueCompare comp);

7
include/boost/intrusive/avltree.hpp
View File

@@ -19,8 +19,9 @@
#include <boost/intrusive/detail/config_begin.hpp> #include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/intrusive_fwd.hpp> #include <boost/intrusive/intrusive_fwd.hpp>
#include <cstddef> #include <cstddef>
#include <functional> #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
#include <utility> #include <boost/intrusive/detail/minimal_pair_header.hpp>
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
#include <boost/intrusive/avl_set_hook.hpp> #include <boost/intrusive/avl_set_hook.hpp>
@@ -307,7 +308,7 @@ class avltree_impl
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference) //! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
iterator lower_bound(const_reference value); iterator lower_bound(const_reference value);
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare) //! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
template<class KeyType, class KeyValueCompare> template<class KeyType, class KeyValueCompare>
iterator lower_bound(const KeyType& key, KeyValueCompare comp); iterator lower_bound(const KeyType& key, KeyValueCompare comp);

4
include/boost/intrusive/bstree.hpp
View File

@@ -47,9 +47,9 @@
#include <boost/move/utility_core.hpp> #include <boost/move/utility_core.hpp>
#include <boost/move/adl_move_swap.hpp> #include <boost/move/adl_move_swap.hpp>
#include <utility> //pair #include <boost/intrusive/detail/minimal_pair_header.hpp>
#include <cstddef> //size_t... #include <cstddef> //size_t...
#include <functional>//less, equal_to #include <boost/intrusive/detail/minimal_less_equal_header.hpp>//less, equal_to
namespace boost { namespace boost {

27
include/boost/intrusive/bstree_algorithms.hpp
View File

@@ -25,7 +25,8 @@
#include <boost/intrusive/detail/uncast.hpp> #include <boost/intrusive/detail/uncast.hpp>
#include <boost/intrusive/detail/math.hpp> #include <boost/intrusive/detail/math.hpp>
#include <boost/intrusive/detail/algo_type.hpp> #include <boost/intrusive/detail/algo_type.hpp>
#include <utility>
#include <boost/intrusive/detail/minimal_pair_header.hpp>
namespace boost { namespace boost {
namespace intrusive { namespace intrusive {
@@ -996,7 +997,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
(const const_node_ptr & header, const KeyType &key (const const_node_ptr & header, const KeyType &key
,KeyNodePtrCompare comp, insert_commit_data &commit_data ,KeyNodePtrCompare comp, insert_commit_data &commit_data
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1073,7 +1074,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
(const const_node_ptr & header, const node_ptr &hint, const KeyType &key (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
,KeyNodePtrCompare comp, insert_commit_data &commit_data ,KeyNodePtrCompare comp, insert_commit_data &commit_data
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1112,7 +1113,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
static node_ptr insert_equal static node_ptr insert_equal
(const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1138,7 +1139,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
static node_ptr insert_equal_upper_bound static node_ptr insert_equal_upper_bound
(const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1164,7 +1165,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
static node_ptr insert_equal_lower_bound static node_ptr insert_equal_lower_bound
(const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1191,7 +1192,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
static node_ptr insert_before static node_ptr insert_before
(const node_ptr & header, const node_ptr & pos, const node_ptr & new_node (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1217,7 +1218,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
static void push_back static void push_back
(const node_ptr & header, const node_ptr & new_node (const node_ptr & header, const node_ptr & new_node
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1242,7 +1243,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
static void push_front static void push_front
(const node_ptr & header, const node_ptr & new_node (const node_ptr & header, const node_ptr & new_node
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1585,7 +1586,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
(const node_ptr &header, const node_ptr & pos (const node_ptr &header, const node_ptr & pos
, insert_commit_data &commit_data , insert_commit_data &commit_data
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1603,7 +1604,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
static void push_back_check static void push_back_check
(const node_ptr & header, insert_commit_data &commit_data (const node_ptr & header, insert_commit_data &commit_data
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1618,7 +1619,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
static void push_front_check static void push_front_check
(const node_ptr & header, insert_commit_data &commit_data (const node_ptr & header, insert_commit_data &commit_data
#ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
, std::size_t *pdepth = 0 , std::size_t *pdepth = 0
#endif #endif
) )
{ {
@@ -1803,7 +1804,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
} }
} }
size = len; size = len;
} }
static void compress_subtree(node_ptr scanner, std::size_t count) static void compress_subtree(node_ptr scanner, std::size_t count)
{ {

2
include/boost/intrusive/detail/generic_hook.hpp
View File

@@ -134,7 +134,7 @@ class generic_hook
, typename NodeAlgorithms::node , typename NodeAlgorithms::node
, node_holder<typename NodeAlgorithms::node, Tag, BaseHookType> , node_holder<typename NodeAlgorithms::node, Tag, BaseHookType>
>::type >::type
//If this is the a default-tagged base hook derive from a class that //If this is the a default-tagged base hook derive from a class that
//will define an special internal typedef. Containers will be able to detect this //will define an special internal typedef. Containers will be able to detect this
//special typedef and obtain generic_hook's internal types in order to deduce //special typedef and obtain generic_hook's internal types in order to deduce
//value_traits for this hook. //value_traits for this hook.

585
include/boost/intrusive/detail/has_member_function_callable_with.hpp
View File

@@ -1,372 +1,331 @@
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// //
// (C) Copyright Ion Gaztanaga 2011-2014. Distributed under the Boost // (C) Copyright Ion Gaztanaga 2014-2014. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file // Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
// See http://www.boost.org/libs/intrusive for documentation. // See http://www.boost.org/libs/container for documentation.
// //
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// sample.h #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
#if !defined(BOOST_PP_IS_ITERATING) //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
//wrong SFINAE for GCC 4.2/4.3
#if defined(__GNUC__) && !defined(__clang__) && ((__GNUC__*100 + __GNUC_MINOR__*10) >= 340) && ((__GNUC__*100 + __GNUC_MINOR__*10) <= 430)
#define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
#elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200 )
#define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
#endif
#include <cstddef>
#include <boost/move/utility_core.hpp>
#include <boost/move/detail/fwd_macros.hpp>
#ifndef BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED namespace boost_intrusive_hmfcw {
#define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED
#include <boost/intrusive/detail/preprocessor.hpp> typedef char yes_type;
#include <boost/intrusive/detail/mpl.hpp> struct no_type{ char dummy[2]; };
#include <boost/move/utility_core.hpp>
#if defined(BOOST_NO_CXX11_DECLTYPE)
//Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
//wrong SFINAE for GCC 4.2/4.3
#if defined(__GNUC__) && !defined(__clang__) && ((__GNUC__*100 + __GNUC_MINOR__*10) >= 340) && ((__GNUC__*100 + __GNUC_MINOR__*10) <= 430)
#define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
#elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200 )
#define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
#endif
namespace boost_intrusive_has_member_function_callable_with { template<class T>
struct make_dontcare
{
typedef dont_care type;
};
struct dont_care #endif
{
dont_care(...);
};
template<class T> struct dont_care
struct make_dontcare {
{ dont_care(...);
typedef boost_intrusive_has_member_function_callable_with::dont_care type; };
};
struct private_type struct private_type
{ {
static private_type p; static private_type p;
private_type const &operator,(int) const; private_type const &operator,(int) const;
}; };
typedef char yes_type; // sizeof(yes_type) == 1 template<typename T>
struct no_type{ char dummy[2]; }; // sizeof(no_type) == 2 no_type is_private_type(T const &);
yes_type is_private_type(private_type const &);
template<typename T> #endif //#if defined(BOOST_NO_CXX11_DECLTYPE)
no_type is_private_type(T const &);
yes_type is_private_type(private_type const &);
} //boost_intrusive_has_member_function_callable_with #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<typename T> struct remove_cv { typedef T type; };
template<typename T> struct remove_cv<const T> { typedef T type; };
template<typename T> struct remove_cv<const volatile T> { typedef T type; };
template<typename T> struct remove_cv<volatile T> { typedef T type; };
#endif
} //namespace boost_intrusive_hmfcw {
#endif //BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
#error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME before including this header!"
#endif
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
#error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN before including this header!"
#endif
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX
#error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX before including this header!"
#endif
#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX < BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX value MUST be greater or equal than BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN!"
#endif
#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX == 0
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF
#else
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF ,
#endif
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG not defined!"
#endif
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END not defined!"
#endif
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE)
//With decltype and variadic templaes, things are pretty easy
template<typename Fun, class ...Args>
struct BOOST_MOVE_CAT(has_member_function_callable_with_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
{
template<class U>
static decltype(boost::move_detail::declval<U>().
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...)
, boost_intrusive_hmfcw::yes_type()) Test(U* f);
template<class U>
static boost_intrusive_hmfcw::no_type Test(...);
static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
};
#else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_DECLTYPE)
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
//
// has_member_function_callable_with_impl_XXX
// declaration, special case and 0 arg specializaton
//
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_SINGLE_ITERATION /////////////////////////////////////////////////////////
#endif /////////////////////////////////////////////////////////
//
// has_member_function_callable_with_impl_XXX for 1 to N arguments
//
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
#endif //BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_DETAILS_INCLUDED //defined(BOOST_NO_CXX11_DECLTYPE) must be true
template<class Fun, class ...DontCares>
struct FunWrapTmpl : Fun
{
using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(DontCares...) const;
};
#else //!BOOST_PP_IS_ITERATING template<typename Fun, class ...Args>
struct BOOST_MOVE_CAT(has_member_function_callable_with_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, Args...>
{
typedef FunWrapTmpl<typename boost_intrusive_hmfcw::make_dontcare<Args>::type...> FunWrap;
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) ==
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME not defined!" sizeof(boost_intrusive_hmfcw::is_private_type
#endif ( (::boost::move_detail::declval< FunWrap<Fun> >().
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...), 0) )
)
);
};
#else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN //Preprocessor must be used to generate specializations instead of variadic templates
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN not defined!"
#endif
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END not defined!"
#endif
#if BOOST_PP_ITERATION_START() > BOOST_PP_ITERATION_FINISH()
#error "BOOST_PP_ITERATION_START() must be <= BOOST_PP_ITERATION_FINISH()"
#endif
#if BOOST_PP_ITERATION() == BOOST_PP_ITERATION_START()
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
template <typename Type> template <typename Type>
class BOOST_PP_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) class BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
{ {
struct BaseMixin struct BaseMixin
{ {
void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(); void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME();
}; };
struct Base : public ::boost::intrusive::detail::remove_cv<Type>::type, public BaseMixin { Base(); }; struct Base : public boost_intrusive_hmfcw::remove_cv<Type>::type, public BaseMixin {};
template <typename T, T t> class Helper{}; template <typename T, T t> class Helper{};
template <typename U> template <typename U>
static boost_intrusive_has_member_function_callable_with::no_type deduce static boost_intrusive_hmfcw::no_type deduce
(U*, Helper<void (BaseMixin::*)(), &U::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME>* = 0); (U*, Helper<void (BaseMixin::*)(), &U::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME>* = 0);
static boost_intrusive_has_member_function_callable_with::yes_type deduce(...); static boost_intrusive_hmfcw::yes_type deduce(...);
public: public:
static const bool value = static const bool value = sizeof(boost_intrusive_hmfcw::yes_type) == sizeof(deduce((Base*)0));
sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
}; };
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) /////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
//
// has_member_function_callable_with_impl_XXX specializations
//
/////////////////////////////////////////////////////////
template<typename Fun, bool HasFunc template<typename Fun, bool HasFunc BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASSDFLT,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION_FINISH(), BOOST_INTRUSIVE_PP_TEMPLATE_PARAM_VOID_DEFAULT, _)> struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME);
struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl);
//!
template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION_FINISH(), class P)> //No BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME member specialization
struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl) template<typename Fun BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASS,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
<Fun, false BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION_FINISH(), P)> struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
{ <Fun, false BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_TARG,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
static const bool value = false; {
}; static const bool value = false;
//! };
#else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
//0 arg specialization when BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME is present
template<typename Fun, bool HasFunc, class ...Args> #if !defined(BOOST_NO_CXX11_DECLTYPE)
struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl);
template<typename Fun, class ...Args>
struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
<Fun, false, Args...>
{
static const bool value = false;
};
#ifdef BOOST_NO_CXX11_DECLTYPE
//Special case for 0 args
template< class F
, std::size_t N =
sizeof((boost::move_detail::declval<F>().
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME (), 0))>
struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
{
boost_intrusive_has_member_function_callable_with::yes_type dummy;
BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int);
};
//For buggy compilers like MSVC 7.1+ ((F*)0)->func() does not
//SFINAE-out the zeroarg_checker_ instantiation but sizeof yields to 0.
template<class F>
struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<F, 0>
{
boost_intrusive_has_member_function_callable_with::no_type dummy;
BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int);
};
#endif //#ifdef BOOST_NO_CXX11_DECLTYPE
template<typename Fun>
struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
<Fun, true>
{
#ifndef BOOST_NO_CXX11_DECLTYPE
template<class U, class V = decltype(boost::move_detail::declval<U>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()) >
static boost_intrusive_has_member_function_callable_with::yes_type Test(U*);
#else
template<class U>
static BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
<U> Test(BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*);
#endif
template <class U>
static boost_intrusive_has_member_function_callable_with::no_type Test(...);
static const bool value = sizeof(Test< Fun >(0))
== sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
};
template<typename Fun, class ...Args>
struct BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl)
<Fun, true , Args...>
{
template<class ...DontCares>
struct FunWrapTmpl : Fun
{
FunWrapTmpl();
using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
boost_intrusive_has_member_function_callable_with::private_type
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
( DontCares...) const;
};
typedef FunWrapTmpl<typename boost_intrusive_has_member_function_callable_with::make_dontcare<Args>::type...> FunWrap;
static bool const value = (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
( (::boost::move_detail::declval< FunWrap >().
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
( ::boost::move_detail::declval<Args>()... ), 0) )
)
);
};
template<typename Fun, class ...Args>
struct BOOST_PP_CAT( has_member_function_callable_with_
, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
: public BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_
, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
< Fun
, BOOST_PP_CAT( has_member_function_named_
, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME )<Fun>::value
, Args... >
{};
#endif //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
#endif //BOOST_PP_ITERATION() == BOOST_PP_ITERATION_START()
#if BOOST_PP_ITERATION() == 0
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#if !defined(_MSC_VER) || (_MSC_VER < 1600)
#if defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
template<typename Fun> template<typename Fun>
struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
<Fun, true BOOST_PP_ENUM_TRAILING(BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION()), BOOST_INTRUSIVE_PP_IDENTITY, void)>
{ {
//Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and template<class U>
//wrong SFINAE for GCC 4.2/4.3 static decltype(boost::move_detail::declval<U>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
static const bool value = true; , boost_intrusive_hmfcw::yes_type()) Test(U* f);
template<class U>
static boost_intrusive_hmfcw::no_type Test(...);
static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
};
#else //defined(BOOST_NO_CXX11_DECLTYPE)
#if !defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
template<class F, std::size_t N = sizeof(boost::move_detail::declval<F>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(), 0)>
struct BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
{ boost_intrusive_hmfcw::yes_type dummy[N ? 1 : 2]; };
template<typename Fun>
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
{
template<class U> static BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>
Test(BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*);
template<class U> static boost_intrusive_hmfcw::no_type Test(...);
static const bool value = sizeof(Test< Fun >(0)) == sizeof(boost_intrusive_hmfcw::yes_type);
}; };
#else //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED) #else //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
//Special case for 0 args template<typename Fun>
template< class F struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
, std::size_t N = {//GCC [3.4-4.3) gives ICE when instantiating the 0 arg version so it is not supported.
sizeof((boost::move_detail::declval<F>(). static const bool value = true;
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME (), 0))> };
struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
{
boost_intrusive_has_member_function_callable_with::yes_type dummy;
BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int);
};
//For buggy compilers like MSVC 7.1+ ((F*)0)->func() does not #endif//!defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
//SFINAE-out the zeroarg_checker_ instantiation but sizeof yields to 0. #endif //!defined(BOOST_NO_CXX11_DECLTYPE)
template<class F> #endif //#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<F, 0>
{
boost_intrusive_has_member_function_callable_with::no_type dummy;
BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)(int);
};
template<typename Fun> #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX > 0
struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl) //1 to N arg specialization when BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME is present
<Fun, true BOOST_PP_ENUM_TRAILING(BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION()), BOOST_INTRUSIVE_PP_IDENTITY, void)> #if defined(BOOST_NO_CXX11_DECLTYPE)
{ #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION(N)\
template<class U> template<class Fun> struct BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME) : Fun\
static BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U> {\
Test(BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*); using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;\
boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME\
(BOOST_MOVE_REPEAT##N(boost_intrusive_hmfcw::dont_care)) const;\
};\
\
template<typename Fun, BOOST_MOVE_CLASS##N>\
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true, BOOST_MOVE_TARG##N>\
{\
static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) == sizeof(boost_intrusive_hmfcw::is_private_type\
( (::boost::move_detail::declval\
< struct BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun> >().\
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(BOOST_MOVE_DECLVAL##N), 0) )\
)\
);\
};\
//
#else
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION(N)\
template<typename Fun, BOOST_MOVE_CLASS##N>\
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)\
<Fun, true, BOOST_MOVE_TARG##N>\
{\
template<class U>\
static decltype(boost::move_detail::declval<U>().\
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(BOOST_MOVE_DECLVAL##N)\
, boost_intrusive_hmfcw::yes_type()) Test(U* f);\
template<class U>\
static boost_intrusive_hmfcw::no_type Test(...);\
static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);\
};\
//
#endif
////////////////////////////////////
// Build and invoke BOOST_MOVE_ITERATE_NTOM macrofunction, note that N has to be at least 1
////////////////////////////////////
#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN 1
#else
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
#endif
BOOST_MOVE_CAT
(BOOST_MOVE_CAT(BOOST_MOVE_CAT(BOOST_MOVE_ITERATE_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN), TO)
,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)
(BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION)
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN
////////////////////////////////////
// End of BOOST_MOVE_ITERATE_NTOM
////////////////////////////////////
#endif //BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX > 0
template <class U> /////////////////////////////////////////////////////////
static boost_intrusive_has_member_function_callable_with::no_type Test(...); /////////////////////////////////////////////////////////
//
// has_member_function_callable_with_FUNC
//
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
static const bool value = sizeof(Test< Fun >(0)) //Otherwise use the preprocessor
== sizeof(boost_intrusive_has_member_function_callable_with::yes_type); template<typename Fun BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASSDFLT,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
}; struct BOOST_MOVE_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
#endif //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED) : public BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
<Fun
, BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_TARG,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
{};
#endif //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#endif
#else //#if !defined(_MSC_VER) || (_MSC_VER < 1600) BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
template<typename Fun>
struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
<Fun, true BOOST_PP_ENUM_TRAILING(BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION()), BOOST_INTRUSIVE_PP_IDENTITY, void)>
{
template<class U>
static decltype( boost::move_detail::declval<U>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
, boost_intrusive_has_member_function_callable_with::yes_type())
Test(U*);
template<class U> //Undef local macros
static boost_intrusive_has_member_function_callable_with::no_type Test(...); #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF
static const bool value = sizeof(Test<Fun>(0)) //Undef user defined macros
== sizeof(boost_intrusive_has_member_function_callable_with::yes_type); #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
}; #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
#endif //#if !defined(_MSC_VER) || (_MSC_VER < 1600) #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
#else //#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
#endif //#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
#else //BOOST_PP_ITERATION() == 0
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), class P)>
struct BOOST_PP_CAT( BOOST_PP_CAT(has_member_function_callable_with_
, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
<Fun, true
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), P)
BOOST_PP_ENUM_TRAILING( BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION())
, BOOST_INTRUSIVE_PP_IDENTITY
, void)>
{
struct FunWrap : Fun
{
FunWrap();
using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
boost_intrusive_has_member_function_callable_with::private_type
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
( BOOST_PP_ENUM(BOOST_PP_ITERATION()
, BOOST_INTRUSIVE_PP_IDENTITY
, boost_intrusive_has_member_function_callable_with::dont_care)) const;
};
static bool const value =
(sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
( (boost::move_detail::declval<FunWrap>().
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
( BOOST_PP_ENUM( BOOST_PP_ITERATION(), BOOST_INTRUSIVE_PP_DECLVAL, _) ), 0
)
)
)
);
};
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
#endif //#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#endif //BOOST_PP_ITERATION() == 0
#if BOOST_PP_ITERATION() == BOOST_PP_ITERATION_FINISH()
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
template<typename Fun
BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION_FINISH(), BOOST_INTRUSIVE_PP_TEMPLATE_PARAM_VOID_DEFAULT, _)>
struct BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
: public BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME), _impl)
<Fun, BOOST_PP_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION_FINISH(), P) >
{};
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
#endif //#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEGIN
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
#endif //#if BOOST_PP_ITERATION() == BOOST_PP_ITERATION_FINISH()
#endif //!BOOST_PP_IS_ITERATING

33
include/boost/intrusive/detail/iterator.hpp
View File

@@ -19,10 +19,13 @@
#include <cstddef> #include <cstddef>
#include <boost/intrusive/detail/std_fwd.hpp> #include <boost/intrusive/detail/std_fwd.hpp>
#include <boost/move/detail/iterator_traits.hpp>
namespace boost { namespace boost {
namespace intrusive { namespace intrusive {
using boost::movelib::iterator_traits;
template<class Category, class T, class Distance, class Pointer = T*, class Reference = T&> template<class Category, class T, class Distance, class Pointer = T*, class Reference = T&>
struct iterator struct iterator
{ {
@@ -33,36 +36,6 @@ struct iterator
typedef Reference reference; typedef Reference reference;
}; };
template<class Iterator>
struct iterator_traits
{
typedef typename Iterator::difference_type difference_type;
typedef typename Iterator::value_type value_type;
typedef typename Iterator::pointer pointer;
typedef typename Iterator::reference reference;
typedef typename Iterator::iterator_category iterator_category;
};
template<class T>
struct iterator_traits<T*>
{
typedef std::ptrdiff_t difference_type;
typedef T value_type;
typedef T* pointer;
typedef T& reference;
typedef std::random_access_iterator_tag iterator_category;
};
template<class T>
struct iterator_traits<const T*>
{
typedef std::ptrdiff_t difference_type;
typedef T value_type;
typedef const T* pointer;
typedef const T& reference;
typedef std::random_access_iterator_tag iterator_category;
};
namespace detail { namespace detail {
template<class InputIt, class Distance> inline template<class InputIt, class Distance> inline

30
include/boost/intrusive/detail/minimal_less_equal_header.hpp Normal file
View File

@@ -0,0 +1,30 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2014-2015
//
// 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/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTRUSIVE_DETAIL_MINIMAL_LESS_EQUAL_HEADER_HPP
#define BOOST_INTRUSIVE_DETAIL_MINIMAL_LESS_EQUAL_HEADER_HPP
#
#if defined(_MSC_VER)
# pragma once
#endif
#
#ifndef BOOST_CONFIG_HPP
# include <boost/config.hpp>
#endif
#
#//Try to avoid including <functional>, as it's quite big in C++11
#if defined(BOOST_GNU_STDLIB)
# include <bits/stl_function.h>
#else
# include <functional> //Fallback
#endif
#
#endif //BOOST_INTRUSIVE_DETAIL_MINIMAL_LESS_EQUAL_HEADER_HPP

30
include/boost/intrusive/detail/minimal_pair_header.hpp Normal file
View File

@@ -0,0 +1,30 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2014-2015
//
// 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/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP
#define BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP
#
#if defined(_MSC_VER)
# pragma once
#endif
#
#ifndef BOOST_CONFIG_HPP
# include <boost/config.hpp>
#endif
#
#//Try to avoid including <utility>, as it's quite big in C++11
#if defined(BOOST_GNU_STDLIB)
# include <bits/stl_pair.h>
#else
# include <utility> //Fallback
#endif
#
#endif //BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP

29
include/boost/intrusive/detail/mpl.hpp
View File

@@ -315,7 +315,14 @@ template <> struct unvoid_ref<const void> { struct type_impl { }; typedef type_i
::boost::intrusive::detail::if_c \ ::boost::intrusive::detail::if_c \
<value, T, DefaultWrap>::type::TNAME type; \ <value, T, DefaultWrap>::type::TNAME type; \
}; \ }; \
\ //
#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \
typename INSTANTIATION_NS_PREFIX \
boost_intrusive_default_type_ ## TNAME< T, TIMPL >::type \
//
#define BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(TNAME)\
template <typename T, typename DefaultType> \ template <typename T, typename DefaultType> \
struct boost_intrusive_eval_default_type_ ## TNAME \ struct boost_intrusive_eval_default_type_ ## TNAME \
{ \ { \
@@ -339,11 +346,6 @@ template <> struct unvoid_ref<const void> { struct type_impl { }; typedef type_i
}; \ }; \
// //
#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \
typename INSTANTIATION_NS_PREFIX \
boost_intrusive_default_type_ ## TNAME< T, TIMPL >::type \
//
#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \ #define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \
typename INSTANTIATION_NS_PREFIX \ typename INSTANTIATION_NS_PREFIX \
boost_intrusive_eval_default_type_ ## TNAME< T, TIMPL >::type \ boost_intrusive_eval_default_type_ ## TNAME< T, TIMPL >::type \
@@ -367,18 +369,17 @@ struct TRAITS_PREFIX##_bool_is_true\
};\ };\
// //
template<typename T, T> struct helper;
#define BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(TRAITS_NAME, FUNC_NAME) \ #define BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(TRAITS_NAME, FUNC_NAME) \
template <typename U, typename Signature> \ template <typename U, typename Signature> \
class TRAITS_NAME \ class TRAITS_NAME \
{ \ { \
private: \ private: \
template<Signature> struct helper;\
template<typename T> \ template<typename T> \
static yes_type check(helper<Signature, &T::FUNC_NAME>*); \ static ::boost::intrusive::detail::yes_type check(helper<&T::FUNC_NAME>*); \
template<typename T> static no_type check(...); \ template<typename T> static ::boost::intrusive::detail::no_type check(...); \
public: \ public: \
static const bool value = sizeof(check<U>(0)) == sizeof(yes_type); \ static const bool value = sizeof(check<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); \
}; \ }; \
// //
@@ -393,9 +394,9 @@ struct TRAITS_NAME \
struct Base : public Type, public BaseMixin { Base(); }; \ struct Base : public Type, public BaseMixin { Base(); }; \
template <typename T, T t> class Helper{}; \ template <typename T, T t> class Helper{}; \
template <typename U> \ template <typename U> \
static no_type check(U*, Helper<void (BaseMixin::*)(), &U::FUNC_NAME>* = 0); \ static ::boost::intrusive::detail::no_type check(U*, Helper<void (BaseMixin::*)(), &U::FUNC_NAME>* = 0); \
static yes_type check(...); \ static ::boost::intrusive::detail::yes_type check(...); \
static const bool value = sizeof(yes_type) == sizeof(check((Base*)(0))); \ static const bool value = sizeof(::boost::intrusive::detail::yes_type) == sizeof(check((Base*)(0))); \
};\ };\
// //

2
include/boost/intrusive/detail/parent_from_member.hpp
View File

@@ -48,7 +48,7 @@ inline std::ptrdiff_t offset_from_pointer_to_member(const Member Parent::* ptr_t
caster.ptr_to_member = ptr_to_member; caster.ptr_to_member = ptr_to_member;
return std::ptrdiff_t(caster.offset); return std::ptrdiff_t(caster.offset);
//Additional info on MSVC behaviour for the future. For 2/3 int ptr-to-member //Additional info on MSVC behaviour for the future. For 2/3 int ptr-to-member
//types dereference seems to be: //types dereference seems to be:
// //
// vboffset = [compile_time_offset if 2-int ptr2memb] / // vboffset = [compile_time_offset if 2-int ptr2memb] /

10
include/boost/intrusive/detail/pointer_element.hpp
View File

@@ -15,7 +15,9 @@
# pragma once # pragma once
#endif #endif
#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
#include <boost/intrusive/detail/workaround.hpp> #include <boost/intrusive/detail/workaround.hpp>
#endif //BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
namespace boost { namespace boost {
namespace intrusive { namespace intrusive {
@@ -118,14 +120,6 @@ template <typename T> struct first_param
< TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7, P8> > < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7, P8> >
{ typedef T type; }; { typedef T type; };
template < template //10arg
<class,class,class,class,class,class,class,class,class,class,class
> class TemplateClass, class T
, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
struct first_param
< TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> >
{ typedef T type; };
#endif //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #endif //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template <typename T> template <typename T>

6
include/boost/intrusive/detail/workaround.hpp
View File

@@ -8,8 +8,8 @@
// //
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTRUSIVE_DETAIL_WRKRND_HPP #ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
#define BOOST_INTRUSIVE_DETAIL_WRKRND_HPP #define BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
#if defined(_MSC_VER) #if defined(_MSC_VER)
# pragma once # pragma once
@@ -31,4 +31,4 @@
#define BOOST_INTRUSIVE_DOCIGN(T1) T1 #define BOOST_INTRUSIVE_DOCIGN(T1) T1
#endif //#ifndef BOOST_INTRUSIVE_DETAIL_WRKRND_HPP #endif //#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP

10
include/boost/intrusive/hashtable.hpp
View File

@@ -45,8 +45,8 @@
#include <boost/move/adl_move_swap.hpp> #include <boost/move/adl_move_swap.hpp>
//std C++ //std C++
#include <functional> //std::equal_to #include <boost/intrusive/detail/minimal_less_equal_header.hpp> //std::equal_to
#include <utility> //std::pair #include <boost/intrusive/detail/minimal_pair_header.hpp> //std::pair
#include <algorithm> //std::lower_bound, std::upper_bound #include <algorithm> //std::lower_bound, std::upper_bound
#include <cstddef> //std::size_t #include <cstddef> //std::size_t
@@ -1317,7 +1317,7 @@ class hashtable_impl
typedef detail::transform_iterator typedef detail::transform_iterator
< typename slist_impl::iterator < typename slist_impl::iterator
, downcast_node_to_value_t , downcast_node_to_value_t
< value_traits < value_traits
, true> > const_local_iterator; , true> > const_local_iterator;
@@ -1576,7 +1576,7 @@ class hashtable_impl
const bucket_ptr src_buckets = src.priv_bucket_pointer(); const bucket_ptr src_buckets = src.priv_bucket_pointer();
const bucket_ptr dst_buckets = this->priv_bucket_pointer(); const bucket_ptr dst_buckets = this->priv_bucket_pointer();
size_type constructed; size_type constructed;
typedef node_cast_adaptor< detail::node_disposer<Disposer, value_traits, CircularSListAlgorithms> typedef node_cast_adaptor< detail::node_disposer<Disposer, value_traits, CircularSListAlgorithms>
, slist_node_ptr, node_ptr > NodeDisposer; , slist_node_ptr, node_ptr > NodeDisposer;
typedef node_cast_adaptor< detail::node_cloner <Cloner, value_traits, CircularSListAlgorithms> typedef node_cast_adaptor< detail::node_cloner <Cloner, value_traits, CircularSListAlgorithms>
@@ -2813,7 +2813,7 @@ class hashtable_impl
siterator priv_invalid_local_it() const siterator priv_invalid_local_it() const
{ return this->data_type::internal.internal.internal.internal.priv_invalid_local_it(); } { return this->data_type::internal.internal.internal.internal.priv_invalid_local_it(); }
split_traits &priv_split_traits() split_traits &priv_split_traits()
{ return this->data_type::internal.priv_split_traits(); } { return this->data_type::internal.priv_split_traits(); }

2
include/boost/intrusive/linear_slist_algorithms.hpp
View File

@@ -23,7 +23,7 @@
#include <boost/intrusive/detail/common_slist_algorithms.hpp> #include <boost/intrusive/detail/common_slist_algorithms.hpp>
#include <boost/intrusive/detail/algo_type.hpp> #include <boost/intrusive/detail/algo_type.hpp>
#include <cstddef> #include <cstddef>
#include <utility> #include <boost/intrusive/detail/minimal_pair_header.hpp> //std::pair
namespace boost { namespace boost {
namespace intrusive { namespace intrusive {

2
include/boost/intrusive/list.hpp
View File

@@ -43,7 +43,7 @@
#include <boost/move/utility_core.hpp> #include <boost/move/utility_core.hpp>
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
#include <functional>//std::less #include <boost/intrusive/detail/minimal_less_equal_header.hpp>//std::less
#include <cstddef> //std::size_t, etc. #include <cstddef> //std::size_t, etc.
namespace boost { namespace boost {

8
include/boost/intrusive/pointer_rebind.hpp
View File

@@ -15,7 +15,9 @@
# pragma once # pragma once
#endif #endif
#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
#include <boost/intrusive/detail/workaround.hpp> #include <boost/intrusive/detail/workaround.hpp>
#endif //BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
namespace boost { namespace boost {
namespace intrusive { namespace intrusive {
@@ -165,12 +167,6 @@ template <template <class, class, class, class, class, class, class, class, clas
struct pointer_rebinder<Ptr<A, P0, P1, P2, P3, P4, P5, P6, P7, P8>, U, 0u> struct pointer_rebinder<Ptr<A, P0, P1, P2, P3, P4, P5, P6, P7, P8>, U, 0u>
{ typedef Ptr<U, P0, P1, P2, P3, P4, P5, P6, P7, P8> type; }; { typedef Ptr<U, P0, P1, P2, P3, P4, P5, P6, P7, P8> type; };
template <template <class, class, class, class, class, class, class, class, class, class, class> class Ptr //10arg
, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9
, class U>
struct pointer_rebinder<Ptr<A, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>, U, 0u>
{ typedef Ptr<U, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> type; };
#endif //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #endif //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template <typename Ptr, typename U> template <typename Ptr, typename U>

3
include/boost/intrusive/pointer_traits.hpp
View File

@@ -22,7 +22,6 @@
#endif #endif
#include <boost/intrusive/detail/config_begin.hpp> #include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/detail/workaround.hpp> #include <boost/intrusive/detail/workaround.hpp>
#include <boost/intrusive/pointer_rebind.hpp> #include <boost/intrusive/pointer_rebind.hpp>
#include <boost/intrusive/detail/pointer_element.hpp> #include <boost/intrusive/detail/pointer_element.hpp>
@@ -45,7 +44,7 @@ BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_call
BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_const_cast_from, const_cast_from) BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_const_cast_from, const_cast_from)
#endif #endif
BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(element_type) BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(element_type)
BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type) BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference) BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr) BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr)

6
include/boost/intrusive/rbtree.hpp
View File

@@ -19,8 +19,8 @@
#include <boost/intrusive/detail/config_begin.hpp> #include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/intrusive_fwd.hpp> #include <boost/intrusive/intrusive_fwd.hpp>
#include <cstddef> #include <cstddef>
#include <functional> #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
#include <utility> #include <boost/intrusive/detail/minimal_pair_header.hpp> //std::pair
#include <boost/intrusive/set_hook.hpp> #include <boost/intrusive/set_hook.hpp>
#include <boost/intrusive/detail/rbtree_node.hpp> #include <boost/intrusive/detail/rbtree_node.hpp>
@@ -305,7 +305,7 @@ class rbtree_impl
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference) //! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
iterator lower_bound(const_reference value); iterator lower_bound(const_reference value);
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare) //! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
template<class KeyType, class KeyValueCompare> template<class KeyType, class KeyValueCompare>
iterator lower_bound(const KeyType& key, KeyValueCompare comp); iterator lower_bound(const KeyType& key, KeyValueCompare comp);

6
include/boost/intrusive/sgtree.hpp
View File

@@ -41,8 +41,8 @@
#include <boost/move/adl_move_swap.hpp> #include <boost/move/adl_move_swap.hpp>
#include <cstddef> #include <cstddef>
#include <functional> #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
#include <utility> #include <boost/intrusive/detail/minimal_pair_header.hpp> //std::pair
#include <cmath> #include <cmath>
#include <cstddef> #include <cstddef>
@@ -693,7 +693,7 @@ class sgtree_impl
//! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference) //! @copydoc ::boost::intrusive::bstree::lower_bound(const_reference)
iterator lower_bound(const_reference value); iterator lower_bound(const_reference value);
//! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare) //! @copydoc ::boost::intrusive::bstree::lower_bound(const KeyType&,KeyValueCompare)
template<class KeyType, class KeyValueCompare> template<class KeyType, class KeyValueCompare>
iterator lower_bound(const KeyType& key, KeyValueCompare comp); iterator lower_bound(const KeyType& key, KeyValueCompare comp);

4
include/boost/intrusive/slist.hpp
View File

@@ -45,9 +45,9 @@
#include <boost/move/utility_core.hpp> #include <boost/move/utility_core.hpp>
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
#include <functional>//std::less #include <boost/intrusive/detail/minimal_less_equal_header.hpp>//std::less
#include <cstddef> //std::size_t #include <cstddef> //std::size_t
#include <utility> //std::pair #include <boost/intrusive/detail/minimal_pair_header.hpp> //std::pair
namespace boost { namespace boost {
namespace intrusive { namespace intrusive {

4
include/boost/intrusive/splaytree.hpp
View File

@@ -19,8 +19,8 @@
#include <boost/intrusive/detail/config_begin.hpp> #include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/intrusive_fwd.hpp> #include <boost/intrusive/intrusive_fwd.hpp>
#include <cstddef> #include <cstddef>
#include <functional> #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
#include <utility> #include <boost/intrusive/detail/minimal_pair_header.hpp> //std::pair
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
#include <boost/intrusive/bstree.hpp> #include <boost/intrusive/bstree.hpp>

6
proj/vc7ide/_intrusivelib/_intrusivelib.vcproj
View File

@@ -313,6 +313,12 @@
<File <File
RelativePath="..\..\..\..\..\boost\intrusive\detail\math.hpp"> RelativePath="..\..\..\..\..\boost\intrusive\detail\math.hpp">
</File> </File>
<File
RelativePath="..\..\..\..\..\boost\intrusive\detail\minimal_less_equal_header.hpp">
</File>
<File
RelativePath="..\..\..\..\..\boost\intrusive\detail\minimal_pair_header.hpp">
</File>
<File <File
RelativePath="..\..\..\..\..\boost\intrusive\detail\mpl.hpp"> RelativePath="..\..\..\..\..\boost\intrusive\detail\mpl.hpp">
</File> </File>