ndnboost: Also rename BOOST_ to NDNBOOST_
diff --git a/include/ndnboost/unordered/detail/allocate.hpp b/include/ndnboost/unordered/detail/allocate.hpp
index 4ad6724..4d6a8ed 100644
--- a/include/ndnboost/unordered/detail/allocate.hpp
+++ b/include/ndnboost/unordered/detail/allocate.hpp
@@ -6,8 +6,8 @@
// See http://www.boost.org/libs/unordered for documentation
-#ifndef BOOST_UNORDERED_ALLOCATE_HPP
-#define BOOST_UNORDERED_ALLOCATE_HPP
+#ifndef NDNBOOST_UNORDERED_ALLOCATE_HPP
+#define NDNBOOST_UNORDERED_ALLOCATE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
@@ -31,11 +31,11 @@
#include <ndnboost/assert.hpp>
#include <utility>
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#if !defined(NDNBOOST_NO_CXX11_HDR_TUPLE)
#include <tuple>
#endif
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
#pragma warning(push)
#pragma warning(disable:4512) // assignment operator could not be generated.
#pragma warning(disable:4345) // behavior change: an object of POD type
@@ -43,7 +43,7 @@
// will be default-initialized.
#endif
-#define BOOST_UNORDERED_EMPLACE_LIMIT 10
+#define NDNBOOST_UNORDERED_EMPLACE_LIMIT 10
namespace ndnboost { namespace unordered { namespace detail {
@@ -85,85 +85,85 @@
// Either forwarding variadic arguments, or storing the arguments in
// emplace_args##n
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args
-#define BOOST_UNORDERED_EMPLACE_ARGS BOOST_FWD_REF(Args)... args
-#define BOOST_UNORDERED_EMPLACE_FORWARD ndnboost::forward<Args>(args)...
+#define NDNBOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS NDNBOOST_FWD_REF(Args)... args
+#define NDNBOOST_UNORDERED_EMPLACE_FORWARD ndnboost::forward<Args>(args)...
-#define BOOST_UNORDERED_EMPLACE_ARGS1(a0) a0
-#define BOOST_UNORDERED_EMPLACE_ARGS2(a0, a1) a0, a1
-#define BOOST_UNORDERED_EMPLACE_ARGS3(a0, a1, a2) a0, a1, a2
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS1(a0) a0
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS2(a0, a1) a0, a1
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS3(a0, a1, a2) a0, a1, a2
#else
-#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename Args
-#define BOOST_UNORDERED_EMPLACE_ARGS Args const& args
-#define BOOST_UNORDERED_EMPLACE_FORWARD args
+#define NDNBOOST_UNORDERED_EMPLACE_TEMPLATE typename Args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS Args const& args
+#define NDNBOOST_UNORDERED_EMPLACE_FORWARD args
-#define BOOST_UNORDERED_FWD_PARAM(z, n, a) \
- BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(a, n)
+#define NDNBOOST_UNORDERED_FWD_PARAM(z, n, a) \
+ NDNBOOST_FWD_REF(NDNBOOST_PP_CAT(A, n)) NDNBOOST_PP_CAT(a, n)
-#define BOOST_UNORDERED_CALL_FORWARD(z, i, a) \
- ndnboost::forward<BOOST_PP_CAT(A,i)>(BOOST_PP_CAT(a,i))
+#define NDNBOOST_UNORDERED_CALL_FORWARD(z, i, a) \
+ ndnboost::forward<NDNBOOST_PP_CAT(A,i)>(NDNBOOST_PP_CAT(a,i))
-#define BOOST_UNORDERED_EARGS(z, n, _) \
- template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
- struct BOOST_PP_CAT(emplace_args, n) \
+#define NDNBOOST_UNORDERED_EARGS(z, n, _) \
+ template <NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
+ struct NDNBOOST_PP_CAT(emplace_args, n) \
{ \
- BOOST_PP_REPEAT_##z(n, BOOST_UNORDERED_EARGS_MEMBER, _) \
- BOOST_PP_CAT(emplace_args, n) ( \
- BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, b) \
- ) : BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_EARGS_INIT, _) \
+ NDNBOOST_PP_REPEAT_##z(n, NDNBOOST_UNORDERED_EARGS_MEMBER, _) \
+ NDNBOOST_PP_CAT(emplace_args, n) ( \
+ NDNBOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, b) \
+ ) : NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_EARGS_INIT, _) \
{} \
\
}; \
\
- template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
- inline BOOST_PP_CAT(emplace_args, n) < \
- BOOST_PP_ENUM_PARAMS_Z(z, n, A) \
+ template <NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
+ inline NDNBOOST_PP_CAT(emplace_args, n) < \
+ NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A) \
> create_emplace_args( \
- BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, b) \
+ NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_FWD_PARAM, b) \
) \
{ \
- BOOST_PP_CAT(emplace_args, n) < \
- BOOST_PP_ENUM_PARAMS_Z(z, n, A) \
- > e(BOOST_PP_ENUM_PARAMS_Z(z, n, b)); \
+ NDNBOOST_PP_CAT(emplace_args, n) < \
+ NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A) \
+ > e(NDNBOOST_PP_ENUM_PARAMS_Z(z, n, b)); \
return e; \
}
-#define BOOST_UNORDERED_EMPLACE_ARGS1 create_emplace_args
-#define BOOST_UNORDERED_EMPLACE_ARGS2 create_emplace_args
-#define BOOST_UNORDERED_EMPLACE_ARGS3 create_emplace_args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS1 create_emplace_args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS2 create_emplace_args
+#define NDNBOOST_UNORDERED_EMPLACE_ARGS3 create_emplace_args
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if defined(NDNBOOST_NO_CXX11_RVALUE_REFERENCES)
-#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _) \
- typedef BOOST_FWD_REF(BOOST_PP_CAT(A, n)) BOOST_PP_CAT(Arg, n); \
- BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, n);
+#define NDNBOOST_UNORDERED_EARGS_MEMBER(z, n, _) \
+ typedef NDNBOOST_FWD_REF(NDNBOOST_PP_CAT(A, n)) NDNBOOST_PP_CAT(Arg, n); \
+ NDNBOOST_PP_CAT(Arg, n) NDNBOOST_PP_CAT(a, n);
-#define BOOST_UNORDERED_EARGS_INIT(z, n, _) \
- BOOST_PP_CAT(a, n)( \
- ndnboost::forward<BOOST_PP_CAT(A,n)>(BOOST_PP_CAT(b, n)))
+#define NDNBOOST_UNORDERED_EARGS_INIT(z, n, _) \
+ NDNBOOST_PP_CAT(a, n)( \
+ ndnboost::forward<NDNBOOST_PP_CAT(A,n)>(NDNBOOST_PP_CAT(b, n)))
#else
-#define BOOST_UNORDERED_EARGS_MEMBER(z, n, _) \
- typedef typename ndnboost::add_lvalue_reference<BOOST_PP_CAT(A, n)>::type \
- BOOST_PP_CAT(Arg, n); \
- BOOST_PP_CAT(Arg, n) BOOST_PP_CAT(a, n);
+#define NDNBOOST_UNORDERED_EARGS_MEMBER(z, n, _) \
+ typedef typename ndnboost::add_lvalue_reference<NDNBOOST_PP_CAT(A, n)>::type \
+ NDNBOOST_PP_CAT(Arg, n); \
+ NDNBOOST_PP_CAT(Arg, n) NDNBOOST_PP_CAT(a, n);
-#define BOOST_UNORDERED_EARGS_INIT(z, n, _) \
- BOOST_PP_CAT(a, n)(BOOST_PP_CAT(b, n))
+#define NDNBOOST_UNORDERED_EARGS_INIT(z, n, _) \
+ NDNBOOST_PP_CAT(a, n)(NDNBOOST_PP_CAT(b, n))
#endif
-BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT, BOOST_UNORDERED_EARGS,
+NDNBOOST_PP_REPEAT_FROM_TO(1, NDNBOOST_UNORDERED_EMPLACE_LIMIT, NDNBOOST_UNORDERED_EARGS,
_)
-#undef BOOST_UNORDERED_DEFINE_EMPLACE_ARGS
-#undef BOOST_UNORDERED_EARGS_MEMBER
-#undef BOOST_UNORDERED_EARGS_INIT
+#undef NDNBOOST_UNORDERED_DEFINE_EMPLACE_ARGS
+#undef NDNBOOST_UNORDERED_EARGS_MEMBER
+#undef NDNBOOST_UNORDERED_EARGS_INIT
#endif
@@ -177,21 +177,21 @@
// 1 = std::allocator_traits
// 2 = ndnboost::container::allocator_traits
-#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
+#if !defined(NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
# if defined(__GXX_EXPERIMENTAL_CXX0X__) && \
(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
-# define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
-# elif defined(BOOST_MSVC)
-# if BOOST_MSVC < 1400
+# define NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
+# elif defined(NDNBOOST_MSVC)
+# if NDNBOOST_MSVC < 1400
// Use container's allocator_traits for older versions of Visual
// C++ as I don't test with them.
-# define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 2
+# define NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS 2
# endif
# endif
#endif
-#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
-# define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
+#if !defined(NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
+# define NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
#endif
////////////////////////////////////////////////////////////////////////////////
@@ -199,7 +199,7 @@
// Some utilities for implementing allocator_traits, but useful elsewhere so
// they're always defined.
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#if !defined(NDNBOOST_NO_CXX11_HDR_TYPE_TRAITS)
# include <type_traits>
#endif
@@ -210,7 +210,7 @@
//
// Uses the standard versions if available.
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#if !defined(NDNBOOST_NO_CXX11_HDR_TYPE_TRAITS)
using std::integral_constant;
using std::true_type;
@@ -229,7 +229,7 @@
////////////////////////////////////////////////////////////////////////////
// Explicitly call a destructor
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
#pragma warning(push)
#pragma warning(disable:4100) // unreferenced formal parameter
#endif
@@ -239,7 +239,7 @@
x->~T();
}
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
#pragma warning(pop)
#endif
@@ -247,38 +247,38 @@
// Expression test mechanism
//
// When SFINAE expressions are available, define
- // BOOST_UNORDERED_HAS_FUNCTION which can check if a function call is
- // supported by a class, otherwise define BOOST_UNORDERED_HAS_MEMBER which
+ // NDNBOOST_UNORDERED_HAS_FUNCTION which can check if a function call is
+ // supported by a class, otherwise define NDNBOOST_UNORDERED_HAS_MEMBER which
// can detect if a class has the specified member, but not that it has the
// correct type, this is good enough for a passable impression of
// allocator_traits.
-#if !defined(BOOST_NO_SFINAE_EXPR)
+#if !defined(NDNBOOST_NO_SFINAE_EXPR)
template <typename T, unsigned int> struct expr_test;
template <typename T> struct expr_test<T, sizeof(char)> : T {};
template <typename U> static char for_expr_test(U const&);
-# define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression) \
+# define NDNBOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression) \
template <typename U> \
static typename ndnboost::unordered::detail::expr_test< \
- BOOST_PP_CAT(choice, result), \
+ NDNBOOST_PP_CAT(choice, result), \
sizeof(ndnboost::unordered::detail::for_expr_test(( \
(expression), \
0)))>::type test( \
- BOOST_PP_CAT(choice, count))
+ NDNBOOST_PP_CAT(choice, count))
-# define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result) \
+# define NDNBOOST_UNORDERED_DEFAULT_EXPRESSION(count, result) \
template <typename U> \
- static BOOST_PP_CAT(choice, result)::type test( \
- BOOST_PP_CAT(choice, count))
+ static NDNBOOST_PP_CAT(choice, result)::type test( \
+ NDNBOOST_PP_CAT(choice, count))
-# define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _) \
- struct BOOST_PP_CAT(has_, name) \
+# define NDNBOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _) \
+ struct NDNBOOST_PP_CAT(has_, name) \
{ \
- BOOST_UNORDERED_CHECK_EXPRESSION(1, 1, \
+ NDNBOOST_UNORDERED_CHECK_EXPRESSION(1, 1, \
ndnboost::unordered::detail::make< thing >().name args); \
- BOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2); \
+ NDNBOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2); \
\
enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };\
}
@@ -287,33 +287,33 @@
template <typename T> struct identity { typedef T type; };
-# define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member) \
+# define NDNBOOST_UNORDERED_CHECK_MEMBER(count, result, name, member) \
\
typedef typename ndnboost::unordered::detail::identity<member>::type \
- BOOST_PP_CAT(check, count); \
+ NDNBOOST_PP_CAT(check, count); \
\
- template <BOOST_PP_CAT(check, count) e> \
- struct BOOST_PP_CAT(test, count) { \
- typedef BOOST_PP_CAT(choice, result) type; \
+ template <NDNBOOST_PP_CAT(check, count) e> \
+ struct NDNBOOST_PP_CAT(test, count) { \
+ typedef NDNBOOST_PP_CAT(choice, result) type; \
}; \
\
template <class U> static typename \
- BOOST_PP_CAT(test, count)<&U::name>::type \
- test(BOOST_PP_CAT(choice, count))
+ NDNBOOST_PP_CAT(test, count)<&U::name>::type \
+ test(NDNBOOST_PP_CAT(choice, count))
-# define BOOST_UNORDERED_DEFAULT_MEMBER(count, result) \
- template <class U> static BOOST_PP_CAT(choice, result)::type \
- test(BOOST_PP_CAT(choice, count))
+# define NDNBOOST_UNORDERED_DEFAULT_MEMBER(count, result) \
+ template <class U> static NDNBOOST_PP_CAT(choice, result)::type \
+ test(NDNBOOST_PP_CAT(choice, count))
-# define BOOST_UNORDERED_HAS_MEMBER(name) \
- struct BOOST_PP_CAT(has_, name) \
+# define NDNBOOST_UNORDERED_HAS_MEMBER(name) \
+ struct NDNBOOST_PP_CAT(has_, name) \
{ \
struct impl { \
struct base_mixin { int name; }; \
struct base : public T, public base_mixin {}; \
\
- BOOST_UNORDERED_CHECK_MEMBER(1, 1, name, int base_mixin::*); \
- BOOST_UNORDERED_DEFAULT_MEMBER(2, 2); \
+ NDNBOOST_UNORDERED_CHECK_MEMBER(1, 1, name, int base_mixin::*); \
+ NDNBOOST_UNORDERED_DEFAULT_MEMBER(2, 2); \
\
enum { value = sizeof(choice2::type) == \
sizeof(test<base>(choose())) \
@@ -333,20 +333,20 @@
//
// First our implementation, then later light wrappers around the alternatives
-#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0
+#if NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0
# include <ndnboost/limits.hpp>
# include <ndnboost/utility/enable_if.hpp>
# include <ndnboost/pointer_to_other.hpp>
-# if defined(BOOST_NO_SFINAE_EXPR)
+# if defined(NDNBOOST_NO_SFINAE_EXPR)
# include <ndnboost/type_traits/is_same.hpp>
# endif
-# if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
- !defined(BOOST_NO_SFINAE_EXPR)
-# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
+# if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
+ !defined(NDNBOOST_NO_SFINAE_EXPR)
+# define NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
# else
-# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+# define NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
# endif
namespace ndnboost { namespace unordered { namespace detail {
@@ -355,12 +355,12 @@
template <typename Alloc, typename T>
struct rebind_wrap
{
- typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other type;
+ typedef typename Alloc::NDNBOOST_NESTED_TEMPLATE rebind<T>::other type;
};
-# if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
+# if defined(NDNBOOST_MSVC) && NDNBOOST_MSVC <= 1400
-# define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
+# define NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
template <typename Tp, typename Default> \
struct default_type_ ## tname { \
\
@@ -375,7 +375,7 @@
enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
\
typedef typename ndnboost::detail::if_true<value>:: \
- BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
+ NDNBOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
::type::tname type; \
}
@@ -384,7 +384,7 @@
template <typename T, typename T2>
struct sfinae : T2 {};
-# define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
+# define NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
template <typename Tp, typename Default> \
struct default_type_ ## tname { \
\
@@ -401,41 +401,41 @@
enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
\
typedef typename ndnboost::detail::if_true<value>:: \
- BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
+ NDNBOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
::type::tname type; \
}
# endif
-# define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg) \
+# define NDNBOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg) \
typename default_type_ ## tname<T, arg>::type
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
- BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(void_pointer);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_void_pointer);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(difference_type);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(size_type);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_copy_assignment);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
+ NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
-# if !defined(BOOST_NO_SFINAE_EXPR)
+# if !defined(NDNBOOST_NO_SFINAE_EXPR)
template <typename T>
- BOOST_UNORDERED_HAS_FUNCTION(
+ NDNBOOST_UNORDERED_HAS_FUNCTION(
select_on_container_copy_construction, U const, (), 0
);
template <typename T>
- BOOST_UNORDERED_HAS_FUNCTION(
+ NDNBOOST_UNORDERED_HAS_FUNCTION(
max_size, U const, (), 0
);
-# if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+# if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
template <typename T, typename ValueType, typename... Args>
- BOOST_UNORDERED_HAS_FUNCTION(
+ NDNBOOST_UNORDERED_HAS_FUNCTION(
construct, U, (
ndnboost::unordered::detail::make<ValueType*>(),
ndnboost::unordered::detail::make<Args const>()...), 2
@@ -444,7 +444,7 @@
# else
template <typename T, typename ValueType>
- BOOST_UNORDERED_HAS_FUNCTION(
+ NDNBOOST_UNORDERED_HAS_FUNCTION(
construct, U, (
ndnboost::unordered::detail::make<ValueType*>(),
ndnboost::unordered::detail::make<ValueType const>()), 2
@@ -453,23 +453,23 @@
# endif
template <typename T, typename ValueType>
- BOOST_UNORDERED_HAS_FUNCTION(
+ NDNBOOST_UNORDERED_HAS_FUNCTION(
destroy, U, (ndnboost::unordered::detail::make<ValueType*>()), 1
);
# else
template <typename T>
- BOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
+ NDNBOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
template <typename T>
- BOOST_UNORDERED_HAS_MEMBER(max_size);
+ NDNBOOST_UNORDERED_HAS_MEMBER(max_size);
template <typename T, typename ValueType>
- BOOST_UNORDERED_HAS_MEMBER(construct);
+ NDNBOOST_UNORDERED_HAS_MEMBER(construct);
template <typename T, typename ValueType>
- BOOST_UNORDERED_HAS_MEMBER(destroy);
+ NDNBOOST_UNORDERED_HAS_MEMBER(destroy);
# endif
@@ -516,28 +516,28 @@
typedef Alloc allocator_type;
typedef typename Alloc::value_type value_type;
- typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*)
+ typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*)
pointer;
template <typename T>
struct pointer_to_other : ndnboost::pointer_to_other<pointer, T> {};
- typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
+ typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
typename pointer_to_other<const value_type>::type)
const_pointer;
- //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
+ //typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
// typename pointer_to_other<void>::type)
// void_pointer;
//
- //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
+ //typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
// typename pointer_to_other<const void>::type)
// const_void_pointer;
- typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, difference_type,
+ typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, difference_type,
std::ptrdiff_t) difference_type;
- typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, size_type, std::size_t)
+ typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(Alloc, size_type, std::size_t)
size_type;
// TODO: rebind_alloc and rebind_traits
@@ -556,13 +556,13 @@
public:
-# if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+# if NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
template <typename T, typename... Args>
static typename ndnboost::enable_if_c<
ndnboost::unordered::detail::has_construct<Alloc, T, Args...>
::value>::type
- construct(Alloc& a, T* p, BOOST_FWD_REF(Args)... x)
+ construct(Alloc& a, T* p, NDNBOOST_FWD_REF(Args)... x)
{
a.construct(p, ndnboost::forward<Args>(x)...);
}
@@ -571,7 +571,7 @@
static typename ndnboost::disable_if_c<
ndnboost::unordered::detail::has_construct<Alloc, T, Args...>
::value>::type
- construct(Alloc&, T* p, BOOST_FWD_REF(Args)... x)
+ construct(Alloc&, T* p, NDNBOOST_FWD_REF(Args)... x)
{
new ((void*) p) T(ndnboost::forward<Args>(x)...);
}
@@ -592,7 +592,7 @@
ndnboost::unordered::detail::destroy(p);
}
-# elif !defined(BOOST_NO_SFINAE_EXPR)
+# elif !defined(NDNBOOST_NO_SFINAE_EXPR)
template <typename T>
static typename ndnboost::enable_if_c<
@@ -689,30 +689,30 @@
// Allocator propagation on assignment and swap.
// Return true if lhs is modified.
- typedef BOOST_UNORDERED_DEFAULT_TYPE(
+ typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(
Alloc, propagate_on_container_copy_assignment, false_type)
propagate_on_container_copy_assignment;
- typedef BOOST_UNORDERED_DEFAULT_TYPE(
+ typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(
Alloc,propagate_on_container_move_assignment, false_type)
propagate_on_container_move_assignment;
- typedef BOOST_UNORDERED_DEFAULT_TYPE(
+ typedef NDNBOOST_UNORDERED_DEFAULT_TYPE(
Alloc,propagate_on_container_swap,false_type)
propagate_on_container_swap;
};
}}}
-# undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
-# undef BOOST_UNORDERED_DEFAULT_TYPE
+# undef NDNBOOST_UNORDERED_DEFAULT_TYPE_TMPLT
+# undef NDNBOOST_UNORDERED_DEFAULT_TYPE
////////////////////////////////////////////////////////////////////////////////
//
// std::allocator_traits
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
+#elif NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
# include <memory>
-# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
+# define NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
namespace ndnboost { namespace unordered { namespace detail {
@@ -731,11 +731,11 @@
//
// ndnboost::container::allocator_traits
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
+#elif NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
# include <ndnboost/container/allocator_traits.hpp>
-# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+# define NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
namespace ndnboost { namespace unordered { namespace detail {
@@ -753,7 +753,7 @@
#else
-#error "Invalid BOOST_UNORDERED_USE_ALLOCATOR_TRAITS value."
+#error "Invalid NDNBOOST_UNORDERED_USE_ALLOCATOR_TRAITS value."
#endif
@@ -763,13 +763,13 @@
////////////////////////////////////////////////////////////////////////////
// call_construct
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
-# if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+# if NDNBOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
template <typename Alloc, typename T, typename... Args>
inline void call_construct(Alloc& alloc, T* address,
- BOOST_FWD_REF(Args)... args)
+ NDNBOOST_FWD_REF(Args)... args)
{
ndnboost::unordered::detail::allocator_traits<Alloc>::construct(alloc,
address, ndnboost::forward<Args>(args)...);
@@ -785,7 +785,7 @@
template <typename Alloc, typename T, typename... Args>
inline void call_construct(Alloc&, T* address,
- BOOST_FWD_REF(Args)... args)
+ NDNBOOST_FWD_REF(Args)... args)
{
new((void*) address) T(ndnboost::forward<Args>(args)...);
}
@@ -812,63 +812,63 @@
//
// Used for piecewise construction.
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
-# define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_) \
+# define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_) \
template<typename Alloc, typename T> \
void construct_from_tuple(Alloc& alloc, T* ptr, namespace_ tuple<>) \
{ \
ndnboost::unordered::detail::call_construct(alloc, ptr); \
} \
\
- BOOST_PP_REPEAT_FROM_TO(1, n, \
- BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+ NDNBOOST_PP_REPEAT_FROM_TO(1, n, \
+ NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
-# define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_) \
+# define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_) \
template<typename Alloc, typename T, \
- BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
+ NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
void construct_from_tuple(Alloc& alloc, T* ptr, \
- namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x) \
+ namespace_ tuple<NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x) \
{ \
ndnboost::unordered::detail::call_construct(alloc, ptr, \
- BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
+ NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
); \
}
-# define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) \
+# define NDNBOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) \
namespace_ get<n>(x)
#elif !defined(__SUNPRO_CC)
-# define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_) \
+# define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_) \
template<typename Alloc, typename T> \
void construct_from_tuple(Alloc&, T* ptr, namespace_ tuple<>) \
{ \
new ((void*) ptr) T(); \
} \
\
- BOOST_PP_REPEAT_FROM_TO(1, n, \
- BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+ NDNBOOST_PP_REPEAT_FROM_TO(1, n, \
+ NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
-# define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_) \
+# define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_) \
template<typename Alloc, typename T, \
- BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
+ NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
void construct_from_tuple(Alloc&, T* ptr, \
- namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x) \
+ namespace_ tuple<NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x) \
{ \
new ((void*) ptr) T( \
- BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
+ NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
); \
}
-# define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) \
+# define NDNBOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) \
namespace_ get<n>(x)
#else
template <int N> struct length {};
-# define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_) \
+# define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(n, namespace_) \
template<typename Alloc, typename T> \
void construct_from_tuple_impl( \
ndnboost::unordered::detail::length<0>, Alloc&, T* ptr, \
@@ -877,35 +877,35 @@
new ((void*) ptr) T(); \
} \
\
- BOOST_PP_REPEAT_FROM_TO(1, n, \
- BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
+ NDNBOOST_PP_REPEAT_FROM_TO(1, n, \
+ NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL, namespace_)
-# define BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_) \
+# define NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL(z, n, namespace_) \
template<typename Alloc, typename T, \
- BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
+ NDNBOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
void construct_from_tuple_impl( \
ndnboost::unordered::detail::length<n>, Alloc&, T* ptr, \
- namespace_ tuple<BOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x) \
+ namespace_ tuple<NDNBOOST_PP_ENUM_PARAMS_Z(z, n, A)> const& x) \
{ \
new ((void*) ptr) T( \
- BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
+ NDNBOOST_PP_ENUM_##z(n, NDNBOOST_UNORDERED_GET_TUPLE_ARG, namespace_) \
); \
}
-# define BOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) \
+# define NDNBOOST_UNORDERED_GET_TUPLE_ARG(z, n, namespace_) \
namespace_ get<n>(x)
#endif
-BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, ndnboost::)
+NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, ndnboost::)
-#if !defined(__SUNPRO_CC) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
- BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::)
+#if !defined(__SUNPRO_CC) && !defined(NDNBOOST_NO_CXX11_HDR_TUPLE)
+ NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::)
#endif
-#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE
-#undef BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL
-#undef BOOST_UNORDERED_GET_TUPLE_ARG
+#undef NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE
+#undef NDNBOOST_UNORDERED_CONSTRUCT_FROM_TUPLE_IMPL
+#undef NDNBOOST_UNORDERED_GET_TUPLE_ARG
#if defined(__SUNPRO_CC)
@@ -934,7 +934,7 @@
sizeof(test(choose(), ndnboost::unordered::detail::make<A0>())) };
};
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES)
////////////////////////////////////////////////////////////////////////////
// Construct from variadic parameters
@@ -943,7 +943,7 @@
template <typename Alloc, typename T, typename... Args>
inline void construct_value_impl(Alloc& alloc, T* address,
- BOOST_FWD_REF(Args)... args)
+ NDNBOOST_FWD_REF(Args)... args)
{
ndnboost::unordered::detail::call_construct(alloc,
address, ndnboost::forward<Args>(args)...);
@@ -958,7 +958,7 @@
typename A0, typename A1, typename A2>
inline typename enable_if<use_piecewise<A0>, void>::type
construct_value_impl(Alloc& alloc, std::pair<A, B>* address,
- BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+ NDNBOOST_FWD_REF(A0), NDNBOOST_FWD_REF(A1) a1, NDNBOOST_FWD_REF(A2) a2)
{
ndnboost::unordered::detail::construct_from_tuple(alloc,
ndnboost::addressof(address->first), ndnboost::forward<A1>(a1));
@@ -966,7 +966,7 @@
ndnboost::addressof(address->second), ndnboost::forward<A2>(a2));
}
-#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#else // NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES
////////////////////////////////////////////////////////////////////////////////
// Construct from emplace_args
@@ -1004,25 +1004,25 @@
// Use a macro for the rest.
-#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _) \
+#define NDNBOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _) \
template < \
typename Alloc, typename T, \
- BOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A) \
+ NDNBOOST_PP_ENUM_PARAMS_Z(z, num_params, typename A) \
> \
inline void construct_value_impl(Alloc&, T* address, \
- ndnboost::unordered::detail::BOOST_PP_CAT(emplace_args,num_params) < \
- BOOST_PP_ENUM_PARAMS_Z(z, num_params, A) \
+ ndnboost::unordered::detail::NDNBOOST_PP_CAT(emplace_args,num_params) < \
+ NDNBOOST_PP_ENUM_PARAMS_Z(z, num_params, A) \
> const& args) \
{ \
new((void*) address) T( \
- BOOST_PP_ENUM_##z(num_params, BOOST_UNORDERED_CALL_FORWARD, \
+ NDNBOOST_PP_ENUM_##z(num_params, NDNBOOST_UNORDERED_CALL_FORWARD, \
args.a)); \
}
- BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
- BOOST_UNORDERED_CONSTRUCT_IMPL, _)
+ NDNBOOST_PP_REPEAT_FROM_TO(4, NDNBOOST_UNORDERED_EMPLACE_LIMIT,
+ NDNBOOST_UNORDERED_CONSTRUCT_IMPL, _)
-#undef BOOST_UNORDERED_CONSTRUCT_IMPL
+#undef NDNBOOST_UNORDERED_CONSTRUCT_IMPL
// Construct with piece_construct
@@ -1038,7 +1038,7 @@
ndnboost::addressof(address->second), args.a2);
}
-#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif // NDNBOOST_NO_CXX11_VARIADIC_TEMPLATES
}}}
@@ -1086,7 +1086,7 @@
template <typename V>
void construct(V const& v, std::size_t l)
{
- BOOST_ASSERT(!ptr_);
+ NDNBOOST_ASSERT(!ptr_);
length_ = l;
ptr_ = traits::allocate(alloc_, length_);
pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
@@ -1113,7 +1113,7 @@
};
}}}
-#if defined(BOOST_MSVC)
+#if defined(NDNBOOST_MSVC)
#pragma warning(pop)
#endif