Include bind in ndnboost.
diff --git a/ndnboost/detail/binary_search.hpp b/ndnboost/detail/binary_search.hpp
new file mode 100644
index 0000000..da27f39
--- /dev/null
+++ b/ndnboost/detail/binary_search.hpp
@@ -0,0 +1,216 @@
+// Copyright (c) 2000 David Abrahams.
+// 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)
+//
+// Copyright (c) 1994
+// Hewlett-Packard Company
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation. Hewlett-Packard Company makes no
+// representations about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied warranty.
+//
+// Copyright (c) 1996
+// Silicon Graphics Computer Systems, Inc.
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation. Silicon Graphics makes no
+// representations about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied warranty.
+//
+#ifndef BINARY_SEARCH_DWA_122600_H_
+# define BINARY_SEARCH_DWA_122600_H_
+
+# include <ndnboost/detail/iterator.hpp>
+# include <utility>
+
+namespace ndnboost { namespace detail {
+
+template <class ForwardIter, class Tp>
+ForwardIter lower_bound(ForwardIter first, ForwardIter last,
+ const Tp& val)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = ndnboost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (*middle < val) {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ else
+ len = half;
+ }
+ return first;
+}
+
+template <class ForwardIter, class Tp, class Compare>
+ForwardIter lower_bound(ForwardIter first, ForwardIter last,
+ const Tp& val, Compare comp)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = ndnboost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (comp(*middle, val)) {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ else
+ len = half;
+ }
+ return first;
+}
+
+template <class ForwardIter, class Tp>
+ForwardIter upper_bound(ForwardIter first, ForwardIter last,
+ const Tp& val)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = ndnboost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (val < *middle)
+ len = half;
+ else {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ }
+ return first;
+}
+
+template <class ForwardIter, class Tp, class Compare>
+ForwardIter upper_bound(ForwardIter first, ForwardIter last,
+ const Tp& val, Compare comp)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = ndnboost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (comp(val, *middle))
+ len = half;
+ else {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ }
+ return first;
+}
+
+template <class ForwardIter, class Tp>
+std::pair<ForwardIter, ForwardIter>
+equal_range(ForwardIter first, ForwardIter last, const Tp& val)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = ndnboost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle, left, right;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (*middle < val) {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ else if (val < *middle)
+ len = half;
+ else {
+ left = ndnboost::detail::lower_bound(first, middle, val);
+ std::advance(first, len);
+ right = ndnboost::detail::upper_bound(++middle, first, val);
+ return std::pair<ForwardIter, ForwardIter>(left, right);
+ }
+ }
+ return std::pair<ForwardIter, ForwardIter>(first, first);
+}
+
+template <class ForwardIter, class Tp, class Compare>
+std::pair<ForwardIter, ForwardIter>
+equal_range(ForwardIter first, ForwardIter last, const Tp& val,
+ Compare comp)
+{
+ typedef detail::iterator_traits<ForwardIter> traits;
+
+ typename traits::difference_type len = ndnboost::detail::distance(first, last);
+ typename traits::difference_type half;
+ ForwardIter middle, left, right;
+
+ while (len > 0) {
+ half = len >> 1;
+ middle = first;
+ std::advance(middle, half);
+ if (comp(*middle, val)) {
+ first = middle;
+ ++first;
+ len = len - half - 1;
+ }
+ else if (comp(val, *middle))
+ len = half;
+ else {
+ left = ndnboost::detail::lower_bound(first, middle, val, comp);
+ std::advance(first, len);
+ right = ndnboost::detail::upper_bound(++middle, first, val, comp);
+ return std::pair<ForwardIter, ForwardIter>(left, right);
+ }
+ }
+ return std::pair<ForwardIter, ForwardIter>(first, first);
+}
+
+template <class ForwardIter, class Tp>
+bool binary_search(ForwardIter first, ForwardIter last,
+ const Tp& val) {
+ ForwardIter i = ndnboost::detail::lower_bound(first, last, val);
+ return i != last && !(val < *i);
+}
+
+template <class ForwardIter, class Tp, class Compare>
+bool binary_search(ForwardIter first, ForwardIter last,
+ const Tp& val,
+ Compare comp) {
+ ForwardIter i = ndnboost::detail::lower_bound(first, last, val, comp);
+ return i != last && !comp(val, *i);
+}
+
+}} // namespace ndnboost::detail
+
+#endif // BINARY_SEARCH_DWA_122600_H_
diff --git a/ndnboost/detail/endian.hpp b/ndnboost/detail/endian.hpp
new file mode 100644
index 0000000..ccee87f
--- /dev/null
+++ b/ndnboost/detail/endian.hpp
@@ -0,0 +1,126 @@
+// Copyright 2005 Caleb Epstein
+// Copyright 2006 John Maddock
+// Copyright 2010 Rene Rivera
+// Distributed under the Boost Software License, Version 1.0. (See accompany-
+// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+/*
+ * Copyright notice reproduced from <ndnboost/detail/limits.hpp>, from
+ * which this code was originally taken.
+ *
+ * Modified by Caleb Epstein to use <endian.h> with GNU libc and to
+ * defined the BOOST_ENDIAN macro.
+ */
+
+#ifndef BOOST_DETAIL_ENDIAN_HPP
+#define BOOST_DETAIL_ENDIAN_HPP
+
+//
+// Special cases come first:
+//
+#if defined (__GLIBC__)
+// GNU libc offers the helpful header <endian.h> which defines
+// __BYTE_ORDER
+# include <endian.h>
+# if (__BYTE_ORDER == __LITTLE_ENDIAN)
+# define BOOST_LITTLE_ENDIAN
+# elif (__BYTE_ORDER == __BIG_ENDIAN)
+# define BOOST_BIG_ENDIAN
+# elif (__BYTE_ORDER == __PDP_ENDIAN)
+# define BOOST_PDP_ENDIAN
+# else
+# error Unknown machine endianness detected.
+# endif
+# define BOOST_BYTE_ORDER __BYTE_ORDER
+
+#elif defined(__NetBSD__) || defined(__FreeBSD__) || \
+ defined(__OpenBSD__) || (__DragonFly__)
+//
+// BSD has endian.h, see https://svn.boost.org/trac/boost/ticket/6013
+# if defined(__OpenBSD__)
+# include <machine/endian.h>
+# else
+# include <sys/endian.h>
+# endif
+# if (_BYTE_ORDER == _LITTLE_ENDIAN)
+# define BOOST_LITTLE_ENDIAN
+# elif (_BYTE_ORDER == _BIG_ENDIAN)
+# define BOOST_BIG_ENDIAN
+# elif (_BYTE_ORDER == _PDP_ENDIAN)
+# define BOOST_PDP_ENDIAN
+# else
+# error Unknown machine endianness detected.
+# endif
+# define BOOST_BYTE_ORDER _BYTE_ORDER
+
+#elif defined( __ANDROID__ )
+// Adroid specific code, see: https://svn.boost.org/trac/boost/ticket/7528
+// Here we can use machine/_types.h, see:
+// http://stackoverflow.com/questions/6212951/endianness-of-android-ndk
+# include "machine/_types.h"
+# ifdef __ARMEB__
+# define BOOST_BIG_ENDIAN
+# define BOOST_BYTE_ORDER 4321
+# else
+# define BOOST_LITTLE_ENDIAN
+# define BOOST_BYTE_ORDER 1234
+# endif // __ARMEB__
+
+#elif defined( _XBOX )
+//
+// XBox is always big endian??
+//
+# define BOOST_BIG_ENDIAN
+# define BOOST_BYTE_ORDER 4321
+
+#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) || \
+ defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) || \
+ defined(__BIGENDIAN__) && !defined(__LITTLEENDIAN__) || \
+ defined(_STLP_BIG_ENDIAN) && !defined(_STLP_LITTLE_ENDIAN)
+# define BOOST_BIG_ENDIAN
+# define BOOST_BYTE_ORDER 4321
+#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) || \
+ defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) || \
+ defined(__LITTLEENDIAN__) && !defined(__BIGENDIAN__) || \
+ defined(_STLP_LITTLE_ENDIAN) && !defined(_STLP_BIG_ENDIAN)
+# define BOOST_LITTLE_ENDIAN
+# define BOOST_BYTE_ORDER 1234
+#elif defined(__sparc) || defined(__sparc__) \
+ || defined(_POWER) || defined(__powerpc__) \
+ || defined(__ppc__) || defined(__hpux) || defined(__hppa) \
+ || defined(_MIPSEB) || defined(_POWER) \
+ || defined(__s390__) || defined(__ARMEB__)
+# define BOOST_BIG_ENDIAN
+# define BOOST_BYTE_ORDER 4321
+#elif defined(__i386__) || defined(__alpha__) \
+ || defined(__ia64) || defined(__ia64__) \
+ || defined(_M_IX86) || defined(_M_IA64) \
+ || defined(_M_ALPHA) || defined(__amd64) \
+ || defined(__amd64__) || defined(_M_AMD64) \
+ || defined(__x86_64) || defined(__x86_64__) \
+ || defined(_M_X64) || defined(__bfin__) \
+ || defined(__ARMEL__) \
+ || (defined(_WIN32) && defined(__ARM__) && defined(_MSC_VER)) // ARM Windows CE don't define anything reasonably unique, but there are no big-endian Windows versions
+
+# define BOOST_LITTLE_ENDIAN
+# define BOOST_BYTE_ORDER 1234
+#else
+# error The file boost/detail/endian.hpp needs to be set up for your CPU type.
+#endif
+
+
+#endif
+
diff --git a/ndnboost/detail/fenv.hpp b/ndnboost/detail/fenv.hpp
new file mode 100644
index 0000000..4618b54
--- /dev/null
+++ b/ndnboost/detail/fenv.hpp
@@ -0,0 +1,74 @@
+/*=============================================================================
+ Copyright (c) 2010 Bryce Lelbach
+
+ 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)
+=============================================================================*/
+
+#include <ndnboost/config.hpp>
+
+#if defined(BOOST_NO_FENV_H)
+ #error This platform does not have a floating point environment
+#endif
+
+#if !defined(BOOST_DETAIL_FENV_HPP)
+#define BOOST_DETAIL_FENV_HPP
+
+/* If we're using clang + glibc, we have to get hacky.
+ * See http://llvm.org/bugs/show_bug.cgi?id=6907 */
+#if defined(__clang__) && (__clang_major__ < 3) && \
+ defined(__GNU_LIBRARY__) && /* up to version 5 */ \
+ defined(__GLIBC__) && /* version 6 + */ \
+ !defined(_FENV_H)
+ #define _FENV_H
+
+ #include <features.h>
+ #include <bits/fenv.h>
+
+ extern "C" {
+ extern int fegetexceptflag (fexcept_t*, int) __THROW;
+ extern int fesetexceptflag (__const fexcept_t*, int) __THROW;
+ extern int feclearexcept (int) __THROW;
+ extern int feraiseexcept (int) __THROW;
+ extern int fetestexcept (int) __THROW;
+ extern int fegetround (void) __THROW;
+ extern int fesetround (int) __THROW;
+ extern int fegetenv (fenv_t*) __THROW;
+ extern int fesetenv (__const fenv_t*) __THROW;
+ extern int feupdateenv (__const fenv_t*) __THROW;
+ extern int feholdexcept (fenv_t*) __THROW;
+
+ #ifdef __USE_GNU
+ extern int feenableexcept (int) __THROW;
+ extern int fedisableexcept (int) __THROW;
+ extern int fegetexcept (void) __THROW;
+ #endif
+ }
+
+ namespace std { namespace tr1 {
+ using ::fenv_t;
+ using ::fexcept_t;
+ using ::fegetexceptflag;
+ using ::fesetexceptflag;
+ using ::feclearexcept;
+ using ::feraiseexcept;
+ using ::fetestexcept;
+ using ::fegetround;
+ using ::fesetround;
+ using ::fegetenv;
+ using ::fesetenv;
+ using ::feupdateenv;
+ using ::feholdexcept;
+ } }
+
+#else /* if we're not using GNU's C stdlib, fenv.h should work with clang */
+ #if defined(__SUNPRO_CC) /* lol suncc */
+ #include <stdio.h>
+ #endif
+
+ #include <fenv.h>
+
+#endif
+
+#endif /* BOOST_DETAIL_FENV_HPP */
+
diff --git a/ndnboost/detail/indirect_traits.hpp b/ndnboost/detail/indirect_traits.hpp
new file mode 100644
index 0000000..fa2d671
--- /dev/null
+++ b/ndnboost/detail/indirect_traits.hpp
@@ -0,0 +1,487 @@
+// Copyright David Abrahams 2002.
+// 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)
+#ifndef INDIRECT_TRAITS_DWA2002131_HPP
+# define INDIRECT_TRAITS_DWA2002131_HPP
+# include <ndnboost/type_traits/is_function.hpp>
+# include <ndnboost/type_traits/is_reference.hpp>
+# include <ndnboost/type_traits/is_pointer.hpp>
+# include <ndnboost/type_traits/is_class.hpp>
+# include <ndnboost/type_traits/is_const.hpp>
+# include <ndnboost/type_traits/is_volatile.hpp>
+# include <ndnboost/type_traits/is_member_function_pointer.hpp>
+# include <ndnboost/type_traits/is_member_pointer.hpp>
+# include <ndnboost/type_traits/remove_cv.hpp>
+# include <ndnboost/type_traits/remove_reference.hpp>
+# include <ndnboost/type_traits/remove_pointer.hpp>
+
+# include <ndnboost/type_traits/detail/ice_and.hpp>
+# include <ndnboost/detail/workaround.hpp>
+
+# include <ndnboost/mpl/eval_if.hpp>
+# include <ndnboost/mpl/if.hpp>
+# include <ndnboost/mpl/bool.hpp>
+# include <ndnboost/mpl/and.hpp>
+# include <ndnboost/mpl/not.hpp>
+# include <ndnboost/mpl/aux_/lambda_support.hpp>
+
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# include <ndnboost/detail/is_function_ref_tester.hpp>
+# endif
+
+namespace ndnboost { namespace detail {
+
+namespace indirect_traits {
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct is_reference_to_const : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_const<T const&> : mpl::true_
+{
+};
+
+# if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
+template<class T>
+struct is_reference_to_const<T const volatile&> : mpl::true_
+{
+};
+# endif
+
+template <class T>
+struct is_reference_to_function : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_function<T&> : is_function<T>
+{
+};
+
+template <class T>
+struct is_pointer_to_function : mpl::false_
+{
+};
+
+// There's no such thing as a pointer-to-cv-function, so we don't need
+// specializations for those
+template <class T>
+struct is_pointer_to_function<T*> : is_function<T>
+{
+};
+
+template <class T>
+struct is_reference_to_member_function_pointer_impl : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_member_function_pointer_impl<T&>
+ : is_member_function_pointer<typename remove_cv<T>::type>
+{
+};
+
+
+template <class T>
+struct is_reference_to_member_function_pointer
+ : is_reference_to_member_function_pointer_impl<T>
+{
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
+};
+
+template <class T>
+struct is_reference_to_function_pointer_aux
+ : mpl::and_<
+ is_reference<T>
+ , is_pointer_to_function<
+ typename remove_cv<
+ typename remove_reference<T>::type
+ >::type
+ >
+ >
+{
+ // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
+};
+
+template <class T>
+struct is_reference_to_function_pointer
+ : mpl::if_<
+ is_reference_to_function<T>
+ , mpl::false_
+ , is_reference_to_function_pointer_aux<T>
+ >::type
+{
+};
+
+template <class T>
+struct is_reference_to_non_const
+ : mpl::and_<
+ is_reference<T>
+ , mpl::not_<
+ is_reference_to_const<T>
+ >
+ >
+{
+};
+
+template <class T>
+struct is_reference_to_volatile : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_volatile<T volatile&> : mpl::true_
+{
+};
+
+# if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
+template <class T>
+struct is_reference_to_volatile<T const volatile&> : mpl::true_
+{
+};
+# endif
+
+
+template <class T>
+struct is_reference_to_pointer : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T*&> : mpl::true_
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const&> : mpl::true_
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* volatile&> : mpl::true_
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const volatile&> : mpl::true_
+{
+};
+
+template <class T>
+struct is_reference_to_class
+ : mpl::and_<
+ is_reference<T>
+ , is_class<
+ typename remove_cv<
+ typename remove_reference<T>::type
+ >::type
+ >
+ >
+{
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
+};
+
+template <class T>
+struct is_pointer_to_class
+ : mpl::and_<
+ is_pointer<T>
+ , is_class<
+ typename remove_cv<
+ typename remove_pointer<T>::type
+ >::type
+ >
+ >
+{
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
+};
+
+# else
+
+using namespace ndnboost::detail::is_function_ref_tester_;
+
+typedef char (&inner_yes_type)[3];
+typedef char (&inner_no_type)[2];
+typedef char (&outer_no_type)[1];
+
+template <typename V>
+struct is_const_help
+{
+ typedef typename mpl::if_<
+ is_const<V>
+ , inner_yes_type
+ , inner_no_type
+ >::type type;
+};
+
+template <typename V>
+struct is_volatile_help
+{
+ typedef typename mpl::if_<
+ is_volatile<V>
+ , inner_yes_type
+ , inner_no_type
+ >::type type;
+};
+
+template <typename V>
+struct is_pointer_help
+{
+ typedef typename mpl::if_<
+ is_pointer<V>
+ , inner_yes_type
+ , inner_no_type
+ >::type type;
+};
+
+template <typename V>
+struct is_class_help
+{
+ typedef typename mpl::if_<
+ is_class<V>
+ , inner_yes_type
+ , inner_no_type
+ >::type type;
+};
+
+template <class T>
+struct is_reference_to_function_aux
+{
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::ndnboost::type_traits::yes_type));
+ typedef mpl::bool_<value> type;
+ };
+
+template <class T>
+struct is_reference_to_function
+ : mpl::if_<is_reference<T>, is_reference_to_function_aux<T>, mpl::bool_<false> >::type
+{
+};
+
+template <class T>
+struct is_pointer_to_function_aux
+{
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value
+ = sizeof(::ndnboost::type_traits::is_function_ptr_tester(t)) == sizeof(::ndnboost::type_traits::yes_type));
+ typedef mpl::bool_<value> type;
+};
+
+template <class T>
+struct is_pointer_to_function
+ : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_<false> >::type
+{
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
+};
+
+struct false_helper1
+{
+ template <class T>
+ struct apply : mpl::false_
+ {
+ };
+};
+
+template <typename V>
+typename is_const_help<V>::type reference_to_const_helper(V&);
+outer_no_type
+reference_to_const_helper(...);
+
+struct true_helper1
+{
+ template <class T>
+ struct apply
+ {
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value
+ = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
+ typedef mpl::bool_<value> type;
+ };
+};
+
+template <bool ref = true>
+struct is_reference_to_const_helper1 : true_helper1
+{
+};
+
+template <>
+struct is_reference_to_const_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_const
+ : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T>
+{
+};
+
+
+template <bool ref = true>
+struct is_reference_to_non_const_helper1
+{
+ template <class T>
+ struct apply
+ {
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value
+ = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
+
+ typedef mpl::bool_<value> type;
+ };
+};
+
+template <>
+struct is_reference_to_non_const_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_non_const
+ : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
+{
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T))
+};
+
+
+template <typename V>
+typename is_volatile_help<V>::type reference_to_volatile_helper(V&);
+outer_no_type
+reference_to_volatile_helper(...);
+
+template <bool ref = true>
+struct is_reference_to_volatile_helper1
+{
+ template <class T>
+ struct apply
+ {
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value
+ = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
+ typedef mpl::bool_<value> type;
+ };
+};
+
+template <>
+struct is_reference_to_volatile_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_volatile
+ : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T>
+{
+};
+
+template <typename V>
+typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
+outer_no_type reference_to_pointer_helper(...);
+
+template <class T>
+struct reference_to_pointer_impl
+{
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value
+ = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
+ );
+
+ typedef mpl::bool_<value> type;
+};
+
+template <class T>
+struct is_reference_to_pointer
+ : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type
+{
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
+};
+
+template <class T>
+struct is_reference_to_function_pointer
+ : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type
+{
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
+};
+
+
+template <class T>
+struct is_member_function_pointer_help
+ : mpl::if_<is_member_function_pointer<T>, inner_yes_type, inner_no_type>
+{};
+
+template <typename V>
+typename is_member_function_pointer_help<V>::type member_function_pointer_helper(V&);
+outer_no_type member_function_pointer_helper(...);
+
+template <class T>
+struct is_pointer_to_member_function_aux
+{
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value
+ = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type));
+ typedef mpl::bool_<value> type;
+};
+
+template <class T>
+struct is_reference_to_member_function_pointer
+ : mpl::if_<
+ is_reference<T>
+ , is_pointer_to_member_function_aux<T>
+ , mpl::bool_<false>
+ >::type
+{
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
+};
+
+template <typename V>
+typename is_class_help<V>::type reference_to_class_helper(V const volatile&);
+outer_no_type reference_to_class_helper(...);
+
+template <class T>
+struct is_reference_to_class
+{
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value
+ = (is_reference<T>::value
+ & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type)))
+ );
+ typedef mpl::bool_<value> type;
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
+};
+
+template <typename V>
+typename is_class_help<V>::type pointer_to_class_helper(V const volatile*);
+outer_no_type pointer_to_class_helper(...);
+
+template <class T>
+struct is_pointer_to_class
+{
+ static T t;
+ BOOST_STATIC_CONSTANT(
+ bool, value
+ = (is_pointer<T>::value
+ && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
+ );
+ typedef mpl::bool_<value> type;
+};
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+}
+
+using namespace indirect_traits;
+
+}} // namespace ndnboost::python::detail
+
+#endif // INDIRECT_TRAITS_DWA2002131_HPP
diff --git a/ndnboost/detail/is_function_ref_tester.hpp b/ndnboost/detail/is_function_ref_tester.hpp
new file mode 100644
index 0000000..b8301ec
--- /dev/null
+++ b/ndnboost/detail/is_function_ref_tester.hpp
@@ -0,0 +1,136 @@
+
+// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes,
+// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.
+// 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)
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+#define BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+
+#include "ndnboost/type_traits/detail/yes_no_type.hpp"
+#include "ndnboost/type_traits/config.hpp"
+
+#if defined(BOOST_TT_PREPROCESSING_MODE)
+# include "ndnboost/preprocessor/iterate.hpp"
+# include "ndnboost/preprocessor/enum_params.hpp"
+# include "ndnboost/preprocessor/comma_if.hpp"
+#endif
+
+namespace ndnboost {
+namespace detail {
+namespace is_function_ref_tester_ {
+
+template <class T>
+ndnboost::type_traits::no_type BOOST_TT_DECL is_function_ref_tester(T& ...);
+
+#if !defined(BOOST_TT_PREPROCESSING_MODE)
+// preprocessor-generated part, don't edit by hand!
+
+template <class R>
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(), int);
+
+template <class R,class T0 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0), int);
+
+template <class R,class T0,class T1 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1), int);
+
+template <class R,class T0,class T1,class T2 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2), int);
+
+template <class R,class T0,class T1,class T2,class T3 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24 >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24), int);
+
+#else
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+ (3, (0, 25, "ndnboost/detail/is_function_ref_tester.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif // BOOST_TT_PREPROCESSING_MODE
+
+} // namespace detail
+} // namespace python
+} // namespace ndnboost
+
+#endif // BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+
+///// iteration
+
+#else
+#define i BOOST_PP_FRAME_ITERATION(1)
+
+template <class R BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T) >
+ndnboost::type_traits::yes_type is_function_ref_tester(R (&)(BOOST_PP_ENUM_PARAMS(i,T)), int);
+
+#undef i
+#endif // BOOST_PP_IS_ITERATING
+
diff --git a/ndnboost/detail/lcast_precision.hpp b/ndnboost/detail/lcast_precision.hpp
new file mode 100644
index 0000000..b763a83
--- /dev/null
+++ b/ndnboost/detail/lcast_precision.hpp
@@ -0,0 +1,184 @@
+// Copyright Alexander Nasonov & Paul A. Bristow 2006.
+
+// Use, modification and distribution are subject to 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)
+
+#ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+#define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+
+#include <climits>
+#include <ios>
+#include <limits>
+
+#include <ndnboost/config.hpp>
+#include <ndnboost/integer_traits.hpp>
+
+#ifndef BOOST_NO_IS_ABSTRACT
+// Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
+#include <ndnboost/mpl/if.hpp>
+#include <ndnboost/type_traits/is_abstract.hpp>
+#endif
+
+#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
+ (defined(BOOST_MSVC) && (BOOST_MSVC<1310))
+
+#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#endif
+
+#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+#include <ndnboost/assert.hpp>
+#else
+#include <ndnboost/static_assert.hpp>
+#endif
+
+namespace ndnboost { namespace detail {
+
+class lcast_abstract_stub {};
+
+#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+// Calculate an argument to pass to std::ios_base::precision from
+// lexical_cast. See alternative implementation for broken standard
+// libraries in lcast_get_precision below. Keep them in sync, please.
+template<class T>
+struct lcast_precision
+{
+#ifdef BOOST_NO_IS_ABSTRACT
+ typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
+#else
+ typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_<
+ ndnboost::is_abstract<T>
+ , std::numeric_limits<lcast_abstract_stub>
+ , std::numeric_limits<T>
+ >::type limits;
+#endif
+
+ BOOST_STATIC_CONSTANT(bool, use_default_precision =
+ !limits::is_specialized || limits::is_exact
+ );
+
+ BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
+ !use_default_precision &&
+ limits::radix == 2 && limits::digits > 0
+ );
+
+ BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
+ !use_default_precision &&
+ limits::radix == 10 && limits::digits10 > 0
+ );
+
+ BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
+ ndnboost::integer_traits<std::streamsize>::const_max
+ );
+
+ BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
+
+ BOOST_STATIC_ASSERT(!is_specialized_dec ||
+ precision_dec <= streamsize_max + 0UL
+ );
+
+ BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
+ 2UL + limits::digits * 30103UL / 100000UL
+ );
+
+ BOOST_STATIC_ASSERT(!is_specialized_bin ||
+ (limits::digits + 0UL < ULONG_MAX / 30103UL &&
+ precision_bin > limits::digits10 + 0UL &&
+ precision_bin <= streamsize_max + 0UL)
+ );
+
+ BOOST_STATIC_CONSTANT(std::streamsize, value =
+ is_specialized_bin ? precision_bin
+ : is_specialized_dec ? precision_dec : 6
+ );
+};
+#endif
+
+template<class T>
+inline std::streamsize lcast_get_precision(T* = 0)
+{
+#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+ return lcast_precision<T>::value;
+#else // Follow lcast_precision algorithm at run-time:
+
+#ifdef BOOST_NO_IS_ABSTRACT
+ typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
+#else
+ typedef BOOST_DEDUCED_TYPENAME ndnboost::mpl::if_<
+ ndnboost::is_abstract<T>
+ , std::numeric_limits<lcast_abstract_stub>
+ , std::numeric_limits<T>
+ >::type limits;
+#endif
+
+ bool const use_default_precision =
+ !limits::is_specialized || limits::is_exact;
+
+ if(!use_default_precision)
+ { // Includes all built-in floating-point types, float, double ...
+ // and UDT types for which digits (significand bits) is defined (not zero)
+
+ bool const is_specialized_bin =
+ limits::radix == 2 && limits::digits > 0;
+ bool const is_specialized_dec =
+ limits::radix == 10 && limits::digits10 > 0;
+ std::streamsize const streamsize_max =
+ (ndnboost::integer_traits<std::streamsize>::max)();
+
+ if(is_specialized_bin)
+ { // Floating-point types with
+ // limits::digits defined by the specialization.
+
+ unsigned long const digits = limits::digits;
+ unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
+ // unsigned long is selected because it is at least 32-bits
+ // and thus ULONG_MAX / 30103UL is big enough for all types.
+ BOOST_ASSERT(
+ digits < ULONG_MAX / 30103UL &&
+ precision > limits::digits10 + 0UL &&
+ precision <= streamsize_max + 0UL
+ );
+ return precision;
+ }
+ else if(is_specialized_dec)
+ { // Decimal Floating-point type, most likely a User Defined Type
+ // rather than a real floating-point hardware type.
+ unsigned int const precision = limits::digits10 + 1U;
+ BOOST_ASSERT(precision <= streamsize_max + 0UL);
+ return precision;
+ }
+ }
+
+ // Integral type (for which precision has no effect)
+ // or type T for which limits is NOT specialized,
+ // so assume stream precision remains the default 6 decimal digits.
+ // Warning: if your User-defined Floating-point type T is NOT specialized,
+ // then you may lose accuracy by only using 6 decimal digits.
+ // To avoid this, you need to specialize T with either
+ // radix == 2 and digits == the number of significand bits,
+ // OR
+ // radix = 10 and digits10 == the number of decimal digits.
+
+ return 6;
+#endif
+}
+
+template<class T>
+inline void lcast_set_precision(std::ios_base& stream, T*)
+{
+ stream.precision(lcast_get_precision<T>());
+}
+
+template<class Source, class Target>
+inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
+{
+ std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
+ std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
+ stream.precision(s > t ? s : t);
+}
+
+}}
+
+#endif // BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
+
diff --git a/ndnboost/detail/reference_content.hpp b/ndnboost/detail/reference_content.hpp
new file mode 100644
index 0000000..52d2c02
--- /dev/null
+++ b/ndnboost/detail/reference_content.hpp
@@ -0,0 +1,141 @@
+//-----------------------------------------------------------------------------
+// boost detail/reference_content.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_DETAIL_REFERENCE_CONTENT_HPP
+#define BOOST_DETAIL_REFERENCE_CONTENT_HPP
+
+#include "ndnboost/config.hpp"
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+# include "ndnboost/mpl/bool.hpp"
+# include "ndnboost/type_traits/has_nothrow_copy.hpp"
+#else
+# include "ndnboost/mpl/if.hpp"
+# include "ndnboost/type_traits/is_reference.hpp"
+#endif
+
+#include "ndnboost/mpl/void.hpp"
+
+namespace ndnboost {
+
+namespace detail {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template reference_content
+//
+// Non-Assignable wrapper for references.
+//
+template <typename RefT>
+class reference_content
+{
+private: // representation
+
+ RefT content_;
+
+public: // structors
+
+ ~reference_content()
+ {
+ }
+
+ reference_content(RefT r)
+ : content_( r )
+ {
+ }
+
+ reference_content(const reference_content& operand)
+ : content_( operand.content_ )
+ {
+ }
+
+private: // non-Assignable
+
+ reference_content& operator=(const reference_content&);
+
+public: // queries
+
+ RefT get() const
+ {
+ return content_;
+ }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction make_reference_content
+//
+// Wraps with reference_content if specified type is reference.
+//
+
+template <typename T = mpl::void_> struct make_reference_content;
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct make_reference_content
+{
+ typedef T type;
+};
+
+template <typename T>
+struct make_reference_content< T& >
+{
+ typedef reference_content<T&> type;
+};
+
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct make_reference_content
+ : mpl::if_<
+ is_reference<T>
+ , reference_content<T>
+ , T
+ >
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
+
+template <>
+struct make_reference_content< mpl::void_ >
+{
+ template <typename T>
+ struct apply
+ : make_reference_content<T>
+ {
+ };
+
+ typedef mpl::void_ type;
+};
+
+} // namespace detail
+
+///////////////////////////////////////////////////////////////////////////////
+// reference_content<T&> type traits specializations
+//
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct has_nothrow_copy<
+ ::ndnboost::detail::reference_content< T& >
+ >
+ : mpl::true_
+{
+};
+
+#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+} // namespace ndnboost
+
+#endif // BOOST_DETAIL_REFERENCE_CONTENT_HPP
diff --git a/ndnboost/detail/select_type.hpp b/ndnboost/detail/select_type.hpp
deleted file mode 100644
index 8e3cac7..0000000
--- a/ndnboost/detail/select_type.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// (C) Copyright David Abrahams 2001.
-// 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 for most recent version including documentation.
-
-// Revision History
-// 09 Feb 01 Applied John Maddock's Borland patch Moving <true>
-// specialization to unspecialized template (David Abrahams)
-// 06 Feb 01 Created (David Abrahams)
-
-#ifndef SELECT_TYPE_DWA20010206_HPP
-# define SELECT_TYPE_DWA20010206_HPP
-
-namespace ndnboost { namespace detail {
-
- // Template class if_true -- select among 2 types based on a bool constant expression
- // Usage:
- // typename if_true<(bool_const_expression)>::template then<true_type, false_type>::type
-
- // HP aCC cannot deal with missing names for template value parameters
- template <bool b> struct if_true
- {
- template <class T, class F>
- struct then { typedef T type; };
- };
-
- template <>
- struct if_true<false>
- {
- template <class T, class F>
- struct then { typedef F type; };
- };
-}}
-#endif // SELECT_TYPE_DWA20010206_HPP
diff --git a/ndnboost/detail/templated_streams.hpp b/ndnboost/detail/templated_streams.hpp
deleted file mode 100644
index b1159f8..0000000
--- a/ndnboost/detail/templated_streams.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost detail/templated_streams.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2003
-// Eric Friedman
-//
-// 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)
-
-#ifndef BOOST_DETAIL_TEMPLATED_STREAMS_HPP
-#define BOOST_DETAIL_TEMPLATED_STREAMS_HPP
-
-#include "ndnboost/config.hpp"
-
-///////////////////////////////////////////////////////////////////////////////
-// (detail) BOOST_TEMPLATED_STREAM_* macros
-//
-// Provides workaround platforms without stream class templates.
-//
-
-#if !defined(BOOST_NO_STD_LOCALE)
-
-#define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) \
- template < typename E , typename T >
-
-#define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) \
- template < typename E , typename T , typename A >
-
-#define BOOST_TEMPLATED_STREAM_ARGS(E,T) \
- typename E , typename T
-
-#define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) \
- typename E , typename T , typename A
-
-#define BOOST_TEMPLATED_STREAM_COMMA ,
-
-#define BOOST_TEMPLATED_STREAM_ELEM(E) E
-#define BOOST_TEMPLATED_STREAM_TRAITS(T) T
-#define BOOST_TEMPLATED_STREAM_ALLOC(A) A
-
-#define BOOST_TEMPLATED_STREAM(X,E,T) \
- BOOST_JOIN(std::basic_,X)< E , T >
-
-#define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \
- BOOST_JOIN(std::basic_,X)< E , T , A >
-
-#else // defined(BOOST_NO_STD_LOCALE)
-
-#define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) /**/
-
-#define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) /**/
-
-#define BOOST_TEMPLATED_STREAM_ARGS(E,T) /**/
-
-#define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) /**/
-
-#define BOOST_TEMPLATED_STREAM_COMMA /**/
-
-#define BOOST_TEMPLATED_STREAM_ELEM(E) char
-#define BOOST_TEMPLATED_STREAM_TRAITS(T) std::char_traits<char>
-#define BOOST_TEMPLATED_STREAM_ALLOC(A) std::allocator<char>
-
-#define BOOST_TEMPLATED_STREAM(X,E,T) \
- std::X
-
-#define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \
- std::X
-
-#endif // BOOST_NO_STD_LOCALE
-
-#endif // BOOST_DETAIL_TEMPLATED_STREAMS_HPP