feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

Remove usage of deprecated macros

Browse Source 
[SVN r81452]
This commit is contained in:
Marshall Clow
2012-11-21 03:12:31 +00:00
parent cfbbba272e
commit e1819c11b2
19 changed files with 37 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/boost/fusion/adapted.hpp
View File

@ -18,7 +18,7 @@
// The std_tuple_iterator adaptor only supports implementations // The std_tuple_iterator adaptor only supports implementations
// using variadic templates // using variadic templates
#if !defined(BOOST_NO_VARIADIC_TEMPLATES) #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#include <boost/fusion/adapted/std_tuple.hpp> #include <boost/fusion/adapted/std_tuple.hpp>
#endif #endif

2
include/boost/fusion/container/deque/back_extended_deque.hpp
View File

@ -31,7 +31,7 @@ namespace boost { namespace fusion
: base(val, deque) : base(val, deque)
{} {}
#if defined(BOOST_NO_RVALUE_REFERENCES) #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename Arg> template <typename Arg>
back_extended_deque(Deque const& deque, Arg& val) back_extended_deque(Deque const& deque, Arg& val)
: base(val, deque) : base(val, deque)

10
include/boost/fusion/container/deque/deque.hpp
View File

@ -13,7 +13,7 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// With variadics, we will use the PP version version // With variadics, we will use the PP version version
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_NO_VARIADIC_TEMPLATES) #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
# include <boost/fusion/container/deque/detail/pp_deque.hpp> # include <boost/fusion/container/deque/detail/pp_deque.hpp>
#else #else
# if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE) # if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
@ -93,7 +93,7 @@ namespace boost { namespace fusion
: base(seq) : base(seq)
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename ...Elements> template <typename ...Elements>
deque(deque<Elements...>&& seq) deque(deque<Elements...>&& seq)
: base(std::forward<deque<Elements...>>(seq)) : base(std::forward<deque<Elements...>>(seq))
@ -104,7 +104,7 @@ namespace boost { namespace fusion
: base(seq) : base(seq)
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
deque(deque&& seq) deque(deque&& seq)
: base(std::forward<deque>(seq)) : base(std::forward<deque>(seq))
{} {}
@ -119,7 +119,7 @@ namespace boost { namespace fusion
: base(detail::deque_keyed_values<Head_, Tail_...>::construct(head, tail...)) : base(detail::deque_keyed_values<Head_, Tail_...>::construct(head, tail...))
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename Head_, typename ...Tail_> template <typename Head_, typename ...Tail_>
explicit deque(Head_&& head, Tail_&&... tail) explicit deque(Head_&& head, Tail_&&... tail)
: base(detail::deque_keyed_values<Head, Tail...> : base(detail::deque_keyed_values<Head, Tail...>
@ -147,7 +147,7 @@ namespace boost { namespace fusion
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename T> template <typename T>
deque& operator=(T&& rhs) deque& operator=(T&& rhs)
{ {

6
include/boost/fusion/container/deque/deque_fwd.hpp
View File

@ -13,9 +13,9 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// With no decltype and variadics, we will use the C++03 version // With no decltype and variadics, we will use the C++03 version
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#if (defined(BOOST_NO_DECLTYPE) \ #if (defined(BOOST_NO_CXX11_DECLTYPE) \
|| defined(BOOST_NO_VARIADIC_TEMPLATES) \ || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) \
|| defined(BOOST_NO_RVALUE_REFERENCES)) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES))
# include <boost/fusion/container/deque/detail/pp_deque_fwd.hpp> # include <boost/fusion/container/deque/detail/pp_deque_fwd.hpp>
#else #else
# if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE) # if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)

2
include/boost/fusion/container/deque/detail/deque_forward_ctor.hpp
View File

@ -34,7 +34,7 @@ deque(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T
: base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::construct(BOOST_PP_ENUM_PARAMS(N, t))) : base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::construct(BOOST_PP_ENUM_PARAMS(N, t)))
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, && t)) deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, && t))
: base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>:: : base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::
forward_(BOOST_PP_ENUM(N, FUSION_DEQUE_FORWARD_CTOR_FORWARD, _))) forward_(BOOST_PP_ENUM(N, FUSION_DEQUE_FORWARD_CTOR_FORWARD, _)))

10
include/boost/fusion/container/deque/detail/keyed_element.hpp
View File

@ -51,7 +51,7 @@ namespace boost { namespace fusion { namespace detail
: Rest(rhs.get_base()), value_(rhs.value_) : Rest(rhs.get_base()), value_(rhs.value_)
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
keyed_element(keyed_element&& rhs) keyed_element(keyed_element&& rhs)
: Rest(std::forward<Rest>(rhs.forward_base())) : Rest(std::forward<Rest>(rhs.forward_base()))
, value_(std::forward<Value>(rhs.value_)) , value_(std::forward<Value>(rhs.value_))
@ -63,7 +63,7 @@ namespace boost { namespace fusion { namespace detail
: Rest(rhs.get_base()), value_(rhs.value_) : Rest(rhs.get_base()), value_(rhs.value_)
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#endif #endif
Rest& get_base() Rest& get_base()
@ -76,7 +76,7 @@ namespace boost { namespace fusion { namespace detail
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
Rest&& forward_base() Rest&& forward_base()
{ {
return std::forward<Rest>(*static_cast<Rest*>(this)); return std::forward<Rest>(*static_cast<Rest*>(this));
@ -99,7 +99,7 @@ namespace boost { namespace fusion { namespace detail
: Rest(rest), value_(value) : Rest(rest), value_(value)
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
keyed_element(Value&& value, Rest&& rest) keyed_element(Value&& value, Rest&& rest)
: Rest(std::forward<Rest>(rest)) : Rest(std::forward<Rest>(rest))
, value_(std::forward<Value>(value)) , value_(std::forward<Value>(value))
@ -125,7 +125,7 @@ namespace boost { namespace fusion { namespace detail
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
keyed_element& operator=(keyed_element&& rhs) keyed_element& operator=(keyed_element&& rhs)
{ {
base::operator=(std::forward<keyed_element>(rhs)); base::operator=(std::forward<keyed_element>(rhs));

6
include/boost/fusion/container/deque/detail/pp_deque.hpp
View File

@ -91,7 +91,7 @@ namespace boost { namespace fusion {
: base(rhs) : base(rhs)
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
explicit deque(T0&& t0) explicit deque(T0&& t0)
: base(std::forward<T0>(t0), detail::nil_keyed_element()) : base(std::forward<T0>(t0), detail::nil_keyed_element())
{} {}
@ -106,7 +106,7 @@ namespace boost { namespace fusion {
: base(seq) : base(seq)
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)> template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>&& seq) deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>&& seq)
: base(std::forward<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>>(seq)) : base(std::forward<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>>(seq))
@ -134,7 +134,7 @@ namespace boost { namespace fusion {
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename T> template <typename T>
deque& deque&
operator=(T&& rhs) operator=(T&& rhs)

2
include/boost/fusion/container/deque/front_extended_deque.hpp
View File

@ -30,7 +30,7 @@ namespace boost { namespace fusion
: base(val, deque) : base(val, deque)
{} {}
#if defined(BOOST_NO_RVALUE_REFERENCES) #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename Arg> template <typename Arg>
front_extended_deque(Deque const& deque, Arg& val) front_extended_deque(Deque const& deque, Arg& val)
: base(val, deque) : base(val, deque)

2
include/boost/fusion/container/vector/detail/vector_forward_ctor.hpp
View File

@ -37,7 +37,7 @@
N, typename detail::call_param<T, >::type _)) N, typename detail::call_param<T, >::type _))
: vec(BOOST_PP_ENUM_PARAMS(N, _)) {} : vec(BOOST_PP_ENUM_PARAMS(N, _)) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#if N == 1 #if N == 1
explicit explicit
#endif #endif

10
include/boost/fusion/container/vector/detail/vector_n.hpp
View File

@ -49,7 +49,7 @@
BOOST_PP_CAT(vector_data, N)() BOOST_PP_CAT(vector_data, N)()
: BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_MEMBER_DEFAULT_INIT, _) {} : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_MEMBER_DEFAULT_INIT, _) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, T, && _)) BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, T, && _))
: BOOST_PP_ENUM(N, FUSION_VECTOR_ARG_FWD, _) {} : BOOST_PP_ENUM(N, FUSION_VECTOR_ARG_FWD, _) {}
#endif #endif
@ -63,7 +63,7 @@
BOOST_PP_CAT(vector_data, N) const& other) BOOST_PP_CAT(vector_data, N) const& other)
: BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_COPY_INIT, _) {} : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_COPY_INIT, _) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
BOOST_PP_CAT(vector_data, N)( BOOST_PP_CAT(vector_data, N)(
BOOST_PP_CAT(vector_data, N)&& other) BOOST_PP_CAT(vector_data, N)&& other)
: BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FWD, _) {} : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FWD, _) {}
@ -123,7 +123,7 @@
N, typename detail::call_param<T, >::type _)) N, typename detail::call_param<T, >::type _))
: base_type(BOOST_PP_ENUM_PARAMS(N, _)) {} : base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#if (N == 1) #if (N == 1)
explicit explicit
#endif #endif
@ -131,7 +131,7 @@
: base_type(BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FORWARD, _)) {} : base_type(BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FORWARD, _)) {}
#endif #endif
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N)&& rhs) BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N)&& rhs)
: base_type(std::forward<base_type>(rhs)) {} : base_type(std::forward<base_type>(rhs)) {}
#endif #endif
@ -178,7 +178,7 @@
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
BOOST_PP_CAT(vector, N)& BOOST_PP_CAT(vector, N)&
operator=(BOOST_PP_CAT(vector, N)&& vec) operator=(BOOST_PP_CAT(vector, N)&& vec)
{ {

4
include/boost/fusion/container/vector/vector.hpp
View File

@ -106,7 +106,7 @@ namespace boost { namespace fusion
vector(vector const& rhs) vector(vector const& rhs)
: vec(rhs.vec) {} : vec(rhs.vec) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
vector(vector&& rhs) vector(vector&& rhs)
: vec(std::forward<vector_n>(rhs.vec)) {} : vec(std::forward<vector_n>(rhs.vec)) {}
#endif #endif
@ -140,7 +140,7 @@ namespace boost { namespace fusion
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
vector& vector&
operator=(vector&& rhs) operator=(vector&& rhs)
{ {

2
include/boost/fusion/functional/adapter/unfused.hpp
View File

@ -100,7 +100,7 @@ namespace boost { namespace fusion
namespace boost namespace boost
{ {
#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_DECLTYPE) #if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_CXX11_DECLTYPE)
template<class F> template<class F>
struct result_of< boost::fusion::unfused<F> const () > struct result_of< boost::fusion::unfused<F> const () >
{ {

2
include/boost/fusion/functional/adapter/unfused_typed.hpp
View File

@ -80,7 +80,7 @@ namespace boost { namespace fusion
namespace boost namespace boost
{ {
#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_DECLTYPE) #if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_CXX11_DECLTYPE)
template<class F, class Seq> template<class F, class Seq>
struct result_of< boost::fusion::unfused_typed<F,Seq> const () > struct result_of< boost::fusion::unfused_typed<F,Seq> const () >
: boost::fusion::unfused_typed<F,Seq>::template result< : boost::fusion::unfused_typed<F,Seq>::template result<

2
include/boost/fusion/support/deduce_sequence.hpp
View File

@ -32,7 +32,7 @@ namespace boost { namespace fusion { namespace traits
{ }; { };
// never called, but needed for decltype-based result_of (C++0x) // never called, but needed for decltype-based result_of (C++0x)
#ifndef BOOST_NO_RVALUE_REFERENCES #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <typename T> template <typename T>
typename result< deducer(T) >::type typename result< deducer(T) >::type
operator()(T&&) const; operator()(T&&) const;

2
include/boost/fusion/view/detail/strictest_traversal.hpp
View File

@ -56,7 +56,7 @@ namespace boost { namespace fusion
}; };
// never called, but needed for decltype-based result_of (C++0x) // never called, but needed for decltype-based result_of (C++0x)
#ifndef BOOST_NO_RVALUE_REFERENCES #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template<typename StrictestSoFar, typename Next> template<typename StrictestSoFar, typename Next>
typename result<strictest_traversal_impl(StrictestSoFar, Next)>::type typename result<strictest_traversal_impl(StrictestSoFar, Next)>::type
operator()(StrictestSoFar&&, Next&&) const; operator()(StrictestSoFar&&, Next&&) const;

2
include/boost/fusion/view/nview/nview.hpp
View File

@ -37,7 +37,7 @@ namespace boost { namespace fusion
template<typename U> template<typename U>
struct result<addref(U)> : add_reference<U> {}; struct result<addref(U)> : add_reference<U> {};
#ifdef BOOST_NO_RVALUE_REFERENCES #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
template <typename T> template <typename T>
typename add_reference<T>::type typename add_reference<T>::type
operator()(T& x) const operator()(T& x) const

2
include/boost/fusion/view/zip_view/detail/value_at_impl.hpp
View File

@ -38,7 +38,7 @@ namespace boost { namespace fusion {
{}; {};
// never called, but needed for decltype-based result_of (C++0x) // never called, but needed for decltype-based result_of (C++0x)
#ifndef BOOST_NO_RVALUE_REFERENCES #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template<typename Seq> template<typename Seq>
typename result<poly_value_at(Seq)>::type typename result<poly_value_at(Seq)>::type
operator()(Seq&&) const; operator()(Seq&&) const;

2
include/boost/fusion/view/zip_view/detail/value_of_impl.hpp
View File

@ -37,7 +37,7 @@ namespace boost { namespace fusion
{}; {};
// never called, but needed for decltype-based result_of (C++0x) // never called, but needed for decltype-based result_of (C++0x)
#ifndef BOOST_NO_RVALUE_REFERENCES #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template<typename It> template<typename It>
typename result<poly_value_of(It)>::type typename result<poly_value_of(It)>::type
operator()(It&&) const; operator()(It&&) const;

4
include/boost/fusion/view/zip_view/zip_view.hpp
View File

@ -68,7 +68,7 @@ namespace boost { namespace fusion {
}; };
// never called, but needed for decltype-based result_of (C++0x) // never called, but needed for decltype-based result_of (C++0x)
#ifndef BOOST_NO_RVALUE_REFERENCES #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template<typename Seq> template<typename Seq>
typename result<seq_ref_size(Seq)>::type typename result<seq_ref_size(Seq)>::type
operator()(Seq&&) const; operator()(Seq&&) const;
@ -89,7 +89,7 @@ namespace boost { namespace fusion {
}; };
// never called, but needed for decltype-based result_of (C++0x) // never called, but needed for decltype-based result_of (C++0x)
#ifndef BOOST_NO_RVALUE_REFERENCES #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template<typename Lhs, typename Rhs> template<typename Lhs, typename Rhs>
typename result<poly_min(Lhs, Rhs)>::type typename result<poly_min(Lhs, Rhs)>::type
operator()(Lhs&&, Rhs&&) const; operator()(Lhs&&, Rhs&&) const;