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

Merge pull request #180 from boostorg/develop

Browse Source 
Merge develop
This commit is contained in:
Kohei Takahashi
2018-05-10 00:59:45 +09:00
committed by GitHub
parent 7899658d8e 98b96c3b97
commit 0c138de7cb
27 changed files with 360 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
.travis.yml
View File

@ -11,11 +11,6 @@ os:
- linux
- osx
branches:
only:
- master
- develop
env:
matrix:
- BOGUS_JOB=true
@ -30,6 +25,20 @@ matrix:
- os: linux
env: TOOLSET=gcc CXXSTD=03,11,1y
- os: linux
env: TOOLSET=gcc-4.4 CXXSTD=98,0x
addons:
apt:
packages:
- g++-4.4
- os: linux
env: TOOLSET=gcc-4.6 CXXSTD=03,0x
addons:
apt:
packages:
- g++-4.6
- os: linux
env: TOOLSET=gcc-4.7 CXXSTD=03,11
addons:
@ -153,6 +162,17 @@ matrix:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-4.0
- os: linux
env: TOOLSET=clang-5.0 CXXSTD=03,11,14,1z,2a
addons:
apt:
packages:
- clang-5.0
- libstdc++-4.9-dev
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-5.0
- os: osx
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z

22
appveyor.yml
View File

@ -7,25 +7,35 @@ version: 1.0.{build}-{branch}
shallow_clone: true
branches:
only:
- master
- develop
environment:
matrix:
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
TOOLSET: msvc-9.0
CXXSTD: latest # fake
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
TOOLSET: msvc-10.0
CXXSTD: latest # fake
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
TOOLSET: msvc-11.0
CXXSTD: latest # fake
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
TOOLSET: msvc-12.0
CXXSTD: latest # fake
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-14.0
CXXSTD: 14
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-14.0
CXXSTD: latest
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TOOLSET: msvc-14.1
CXXSTD: 14
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TOOLSET: msvc-14.1
CXXSTD: 17
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TOOLSET: msvc-14.1
CXXSTD: latest
install:
- set BOOST_BRANCH=develop
@ -72,4 +82,4 @@ install:
build: off
test_script:
- b2 -j%NUMBER_OF_PROCESSORS% --hash libs/fusion/test toolset=%TOOLSET%
- b2 -j%NUMBER_OF_PROCESSORS% --hash libs/fusion/test toolset=%TOOLSET% cxxstd=%CXXSTD%

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

@ -13,6 +13,11 @@
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
#include <boost/core/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#endif
namespace boost { namespace fusion
{
struct fusion_sequence_tag;
@ -114,8 +119,13 @@ namespace boost { namespace fusion { namespace detail
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
template <typename Value_, typename = typename enable_if<is_same<Value_, Value> >::type>
#else
typedef Value Value_;
#endif
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
keyed_element(Value&& value, Rest&& rest)
keyed_element(Value_&& value, Rest&& rest)
: Rest(std::move(rest))
, value_(BOOST_FUSION_FWD_ELEM(Value, value))
{}

4
include/boost/fusion/container/list/cons.hpp
View File

@ -70,6 +70,10 @@ namespace boost { namespace fusion
cons(cons<Car2, Cdr2> const& rhs)
: car(rhs.car), cdr(rhs.cdr) {}
#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 406) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
// Workaround for `array used as initializer` compile error on gcc 4.6 w/ c++0x.
template <typename = void>
#endif
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
cons(cons const& rhs)
: car(rhs.car), cdr(rhs.cdr) {}

6
include/boost/fusion/container/map/detail/map_impl.hpp
View File

@ -125,11 +125,7 @@ namespace boost { namespace fusion { namespace detail
}
BOOST_FUSION_GPU_ENABLED
value_type get_val(mpl::identity<key_type>);
BOOST_FUSION_GPU_ENABLED
pair_type get_val(mpl::int_<index>);
BOOST_FUSION_GPU_ENABLED
value_type get_val(mpl::identity<key_type>) const;
mpl::identity<value_type> get_val(mpl::identity<key_type>) const;
BOOST_FUSION_GPU_ENABLED
pair_type get_val(mpl::int_<index>) const;

11
include/boost/fusion/container/map/detail/value_at_key_impl.hpp
View File

@ -1,5 +1,6 @@
/*=============================================================================
Copyright (c) 2001-2013 Joel de Guzman
Copyright (c) 2018 Kohei Takahashi
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)
@ -8,10 +9,6 @@
#define BOOST_FUSION_MAP_DETAIL_VALUE_AT_KEY_IMPL_02042013_0821
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/utility/declval.hpp>
namespace boost { namespace fusion
@ -29,9 +26,9 @@ namespace boost { namespace fusion
template <typename Sequence, typename Key>
struct apply
{
typedef
decltype(boost::declval<Sequence>().get_val(mpl::identity<Key>()))
type;
typedef typename BOOST_FUSION_IDENTIFIED_TYPE((
boost::declval<Sequence>().get_val(mpl::identity<Key>())
)) type;
};
};
}

12
include/boost/fusion/container/vector/detail/value_at_impl.hpp
View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2014 Kohei Takahashi
Copyright (c) 2014,2018 Kohei Takahashi
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)
@ -7,7 +7,6 @@
#ifndef FUSION_VALUE_AT_IMPL_16122014_1641
#define FUSION_VALUE_AT_IMPL_16122014_1641
#include <boost/config.hpp>
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/container/vector/detail/config.hpp>
@ -23,6 +22,7 @@
///////////////////////////////////////////////////////////////////////////////
#include <boost/fusion/container/vector/vector_fwd.hpp>
#include <boost/type_traits/declval.hpp>
#include <boost/mpl/identity.hpp>
namespace boost { namespace fusion
{
@ -35,7 +35,7 @@ namespace boost { namespace fusion
template <std::size_t N, typename U>
static inline BOOST_FUSION_GPU_ENABLED
U value_at_impl(store<N, U> const volatile*);
mpl::identity<U> value_at_impl(store<N, U> const volatile*);
}
namespace extension
@ -49,9 +49,9 @@ namespace boost { namespace fusion
template <typename Sequence, typename N>
struct apply
{
typedef
decltype(vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>()))
type;
typedef typename BOOST_FUSION_IDENTIFIED_TYPE((
vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>())
)) type;
};
};
}

6
include/boost/fusion/support/category_of.hpp
View File

@ -8,7 +8,6 @@
#define FUSION_CATEGORY_OF_07202005_0308
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/detail/category_of.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/type_traits/is_base_of.hpp>
@ -44,7 +43,10 @@ namespace boost { namespace fusion
struct category_of_impl
{
template<typename T>
struct apply : detail::fusion_category_of<T> {};
struct apply
{
typedef typename T::category type;
};
};
template <>

22
include/boost/fusion/support/config.hpp
View File

@ -1,6 +1,6 @@
/*=============================================================================
Copyright (c) 2014 Eric Niebler
Copyright (c) 2014 Kohei Takahashi
Copyright (c) 2014,2015,2018 Kohei Takahashi
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)
@ -96,4 +96,24 @@ namespace std
#define BOOST_FUSION_CONSTEXPR_THIS BOOST_CONSTEXPR
#endif
// Workaround for compiler which doesn't compile decltype(expr)::type.
// It expects decltype(expr) deduced as mpl::identity<T>.
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913)) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
# include <boost/mpl/identity.hpp>
# define BOOST_FUSION_IDENTIFIED_TYPE(parenthesized_expr) \
boost::mpl::identity<decltype parenthesized_expr>::type::type
#else
# define BOOST_FUSION_IDENTIFIED_TYPE(parenthesized_expr) \
decltype parenthesized_expr ::type
#endif
// Workaround for GCC 4.6 that rejects defaulted function with noexcept.
#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 406)
# define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED
#else
# define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED BOOST_NOEXCEPT
#endif
#endif

8
include/boost/fusion/support/detail/and.hpp
View File

@ -1,5 +1,6 @@
/*=============================================================================
Copyright (c) 2016 Lee Clagett
Copyright (c) 2018 Kohei Takahashi
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)
@ -8,6 +9,7 @@
#define FUSION_AND_07152016_1625
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#include <boost/type_traits/integral_constant.hpp>
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@ -15,6 +17,8 @@
#endif
namespace boost { namespace fusion { namespace detail {
#if defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS) \
|| BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913))
template<typename ...Cond>
struct and_impl : false_type {};
@ -34,6 +38,10 @@ namespace boost { namespace fusion { namespace detail {
recursive. */
template<typename ...Cond>
struct and_ : and_impl1<Cond::value...> {};
#else
template <typename ...Cond>
struct and_ : integral_constant<bool, ((bool)Cond::value && ...)> {};
#endif
}}}
#endif // FUSION_AND_07152016_1625

19
include/boost/fusion/support/detail/category_of.hpp
View File

@ -1,19 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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(FUSION_CATEGORY_OF_07212005_1025)
#define FUSION_CATEGORY_OF_07212005_1025
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct fusion_category_of
{
typedef typename T::category type;
};
}}}
#endif

6
include/boost/fusion/support/detail/is_mpl_sequence.hpp
View File

@ -9,19 +9,17 @@
#define FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/detail/is_native_fusion_sequence.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/type_traits/is_complete.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct is_mpl_sequence
: mpl::and_<
mpl::not_<mpl::and_<is_complete<T>, is_convertible<T, from_sequence_convertible_type> > >
mpl::not_<is_native_fusion_sequence<T> >
, mpl::is_sequence<T> >
{};
}}}

27
include/boost/fusion/support/detail/is_native_fusion_sequence.hpp Normal file
View File

@ -0,0 +1,27 @@
/*=============================================================================
Copyright (c) 2018 Kohei Takahashi
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_FUSION_IS_NATIVE_FUSION_SEQUENCE
#define BOOST_FUSION_IS_NATIVE_FUSION_SEQUENCE
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/mpl/and.hpp>
#include <boost/type_traits/is_complete.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Sequence>
struct is_native_fusion_sequence
: mpl::and_<
is_complete<Sequence>
, is_convertible<Sequence, detail::from_sequence_convertible_type>
>
{};
}}}
#endif

19
include/boost/fusion/support/detail/is_view.hpp
View File

@ -1,19 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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(FUSION_IS_VIEW_03202006_0018)
#define FUSION_IS_VIEW_03202006_0018
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct fusion_is_view
{
typedef typename T::is_view type;
};
}}}
#endif

16
include/boost/fusion/support/detail/unknown_key.hpp
View File

@ -1,16 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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(FUSION_UNKNOWN_KEY_09242005_1219)
#define FUSION_UNKNOWN_KEY_09242005_1219
namespace boost { namespace fusion { namespace detail
{
template <int index>
struct unknown_key {};
}}}
#endif

13
include/boost/fusion/support/is_sequence.hpp
View File

@ -10,13 +10,10 @@
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/mpl/and.hpp>
#include <boost/fusion/support/detail/is_native_fusion_sequence.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/is_complete.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace fusion
{
@ -69,13 +66,7 @@ namespace boost { namespace fusion
>
{};
template <typename Sequence, typename Enable = void>
struct is_native_fusion_sequence
: mpl::and_<
is_complete<Sequence>,
is_convertible<Sequence, fusion::detail::from_sequence_convertible_type>
>
{};
using detail::is_native_fusion_sequence;
}
}}

6
include/boost/fusion/support/is_view.hpp
View File

@ -9,7 +9,6 @@
#include <boost/fusion/support/config.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/fusion/support/detail/is_view.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
@ -28,8 +27,9 @@ namespace boost { namespace fusion
{
template <typename T>
struct apply
: detail::fusion_is_view<T>
{};
{
typedef typename T::is_view type;
};
};
template <>

36
include/boost/fusion/support/unused.hpp
View File

@ -1,5 +1,6 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2018 Kohei Takahashi
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)
@ -10,7 +11,6 @@
#include <boost/fusion/support/config.hpp>
#include <iosfwd>
#include <boost/config.hpp>
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4522) // multiple assignment operators specified warning
@ -23,9 +23,16 @@ namespace boost { namespace fusion
struct unused_type
{
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
unused_type() BOOST_NOEXCEPT
BOOST_DEFAULTED_FUNCTION(
unused_type() BOOST_FUSION_NOEXCEPT_ON_DEFAULTED,
{
}
})
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
BOOST_DEFAULTED_FUNCTION(
unused_type(unused_type const&) BOOST_FUSION_NOEXCEPT_ON_DEFAULTED,
{
})
template <typename T>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@ -33,35 +40,12 @@ namespace boost { namespace fusion
{
}
template <typename T>
BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
unused_type const&
operator=(T const&) const BOOST_NOEXCEPT
{
return *this;
}
template <typename T>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
unused_type&
operator=(T const&) BOOST_NOEXCEPT
{
return *this;
}
BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
unused_type const&
operator=(unused_type const&) const BOOST_NOEXCEPT
{
return *this;
}
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
unused_type&
operator=(unused_type const&) BOOST_NOEXCEPT
{
return *this;
}
};
BOOST_CONSTEXPR_OR_CONST unused_type unused = unused_type();

4
meta/explicit-failures-markup.xml
View File

@ -9,8 +9,8 @@
<toolset name="msvc-11.0"/>
<toolset name="msvc-12.0"/>
<toolset name="qcc-4.4.2_x86"/>
<toolset name="gcc-gnu-4.4~c++0x*"/>
<toolset name="gcc-gnu-4.4~gnu0x*"/>
<toolset name="gcc-4.4~c++0x*"/>
<toolset name="gcc-4.4~gnu0x*"/>
<note author="Kohei Takahashi">
The compiler doesn't generate defaulted move ctor/assgin thus
perform copy construction/assginment. Even though such case,

2
test/Jamfile
View File

@ -237,6 +237,7 @@ project
[ run sequence/ref_vector.cpp ]
[ run sequence/flatten_view.cpp ]
[ compile sequence/github-159.cpp ]
[ run sequence/github-176.cpp ]
[ compile sequence/size.cpp ]
@ -266,6 +267,7 @@ project
[ compile support/and.cpp
: [ requires cxx11_variadic_templates ] ]
[ compile support/tag_of.cpp ]
[ compile support/unused.cpp ]
# [ compile-fail xxx.cpp ]

6
test/sequence/define_struct_inline_move.cpp
View File

@ -47,8 +47,8 @@ int main()
BOOST_TEST(y.w.value == 42);
}
// Older MSVCs don't generate move ctor by default.
#if !(defined(CI_SKIP_KNOWN_FAILURE) && BOOST_WORKAROUND(BOOST_MSVC, < 1900))
// Older MSVCs and gcc 4.4 don't generate move ctor by default.
#if !(defined(CI_SKIP_KNOWN_FAILURE) && (BOOST_WORKAROUND(BOOST_MSVC, < 1900) || BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)))
{
ns::value x;
ns::value y(std::move(x)); // move
@ -66,7 +66,7 @@ int main()
BOOST_TEST(x.w.value == 0);
BOOST_TEST(y.w.value == 0);
}
#endif // !(ci && msvc < 14.0)
#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))
return boost::report_errors();
}

6
test/sequence/define_tpl_struct_inline_move.cpp
View File

@ -47,8 +47,8 @@ int main()
BOOST_TEST(y.w.value == 42);
}
// Older MSVCs don't generate move ctor by default.
#if !(defined(CI_SKIP_KNOWN_FAILURE) && BOOST_WORKAROUND(BOOST_MSVC, < 1900))
// Older MSVCs and gcc 4.4 don't generate move ctor by default.
#if !(defined(CI_SKIP_KNOWN_FAILURE) && (BOOST_WORKAROUND(BOOST_MSVC, < 1900) || BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)))
{
ns::value<wrapper> x;
ns::value<wrapper> y(std::move(x)); // move
@ -66,7 +66,7 @@ int main()
BOOST_TEST(x.w.value == 0);
BOOST_TEST(y.w.value == 0);
}
#endif // !(ci && msvc < 14.0)
#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))
return boost::report_errors();
}

89
test/sequence/github-176.cpp Normal file
View File

@ -0,0 +1,89 @@
/*=============================================================================
Copyright (c) 2018 Kohei Takahashi
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 <boost/fusion/sequence/intrinsic/at.hpp>
#include <boost/fusion/sequence/intrinsic/at_key.hpp>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/container/list.hpp>
#include <boost/fusion/container/deque.hpp>
#include <boost/fusion/container/map.hpp>
#include <boost/fusion/container/set.hpp>
#include <boost/fusion/tuple/tuple.hpp>
#include <boost/core/lightweight_test.hpp>
template <typename Sequence>
void test_at()
{
Sequence seq;
// zero initialized
BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 0);
BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 0);
BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 0);
int (&arr)[3] = boost::fusion::deref(boost::fusion::begin(seq));
arr[0] = 2;
arr[1] = 4;
arr[2] = 6;
BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 2);
BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 4);
BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 6);
boost::fusion::at_c<0>(seq)[1] = 42;
BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 2);
BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 42);
BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 6);
}
template <typename T> inline T& value(T& v) { return v; }
template <typename K, typename T> inline T& value(boost::fusion::pair<K, T>& v) { return v.second; }
template <typename Sequence>
void test_at_key()
{
Sequence seq;
// zero initialized
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 0);
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 0);
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 0);
int (&arr)[3] = value(boost::fusion::deref(boost::fusion::begin(seq)));
arr[0] = 2;
arr[1] = 4;
arr[2] = 6;
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 2);
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 4);
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 6);
boost::fusion::at_key<int[3]>(seq)[1] = 42;
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 2);
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 42);
BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 6);
}
int main()
{
using namespace boost::fusion;
test_at<vector<int[3]> >();
test_at<deque<int[3]> >();
test_at<list<int[3]> >();
test_at<tuple<int[3]> >();
#if !BOOST_WORKAROUND(BOOST_GCC, / 100 == 406) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
// FIXME: gcc 4.6 w/ c++0x doesn't like set with array...
test_at_key<set<int[3]> >();
#endif
test_at_key<map<pair<int[3], int[3]> > >();
}

25
test/sequence/hash.hpp
View File

@ -1,5 +1,6 @@
/*=============================================================================
Copyright (c) 2014 Christoph Weiss
Copyright (c) 2017 Kohei Takahashi
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)
@ -11,24 +12,24 @@
#include <boost/fusion/sequence/hash.hpp>
#include <boost/functional/hash.hpp>
void
hash_test()
void hash_test()
{
using namespace boost::fusion;
namespace fusion = boost::fusion;
using namespace fusion;
const FUSION_SEQUENCE<int, char, bool, std::string> v0(42, 'x', false, "Aurea prima");
const FUSION_SEQUENCE<int, char, bool, std::string> v1(42, 'x', false, "Aurea prima");
BOOST_TEST(hash_value(v0) == hash_value(v1));
BOOST_TEST(fusion::hash_value(v0) == fusion::hash_value(v1));
const FUSION_SEQUENCE<int, char, bool, std::string> w(41, 'x', false, "Aurea prima");
BOOST_TEST(hash_value(w) != hash_value(v0));
BOOST_TEST(fusion::hash_value(w) != fusion::hash_value(v0));
const FUSION_SEQUENCE<int, char, bool, std::string> x(42, 'y', false, "Aurea prima");
BOOST_TEST(hash_value(x) != hash_value(v0));
BOOST_TEST(fusion::hash_value(x) != fusion::hash_value(v0));
const FUSION_SEQUENCE<int, char, bool, std::string> y(42, 'x', true, "Aurea prima");
BOOST_TEST(hash_value(y) != hash_value(v0));
BOOST_TEST(fusion::hash_value(y) != fusion::hash_value(v0));
const FUSION_SEQUENCE<int, char, bool, std::string> z(42, 'x', false, "quae vindice nullo");
BOOST_TEST(hash_value(z) != hash_value(v0));
BOOST_TEST(fusion::hash_value(z) != fusion::hash_value(v0));
}

10
test/sequence/traits.hpp
View File

@ -1,5 +1,6 @@
/*=============================================================================
Copyright (C) 2016 Lee Clagett
Copyright (C) 2018 Kohei Takahashi
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)
@ -38,9 +39,7 @@ bool is_convertible(bool has_conversion)
}
// is_constructible has a few requirements
#if !defined(BOOST_NO_CXX11_DECLTYPE) && \
!defined(BOOST_NO_CXX11_TEMPLATES) && \
!defined(BOOST_NO_SFINAE_EXPR)
#ifdef BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING
#define FUSION_TEST_HAS_CONSTRUCTIBLE
@ -88,7 +87,9 @@ void test_constructible()
BOOST_TEST((
is_constructible<FUSION_SEQUENCE<convertible>, convertible>(true)
));
// boost::is_constructible always fail to test ctor which takes 2 or more arguments on GCC 4.7.
#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
BOOST_TEST((
is_constructible<FUSION_SEQUENCE<int, int>, int, int>(true)
));
@ -131,6 +132,7 @@ void test_constructible()
FUSION_SEQUENCE<convertible, convertible>, convertible, convertible
>(true)
));
#endif // !(gcc < 4.7)
}
#endif // is_constructible is available

3
test/sequence/tuple_traits.cpp
View File

@ -65,10 +65,13 @@ main()
BOOST_TEST((is_constructible<tuple<int>, int, int>(false)));
BOOST_TEST((is_constructible< tuple<int, int> >(true)));
// boost::is_constructible always fail to test ctor which takes 2 or more arguments on GCC 4.7.
#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
BOOST_TEST((is_constructible<tuple<int, int>, int, int>(true)));
BOOST_TEST((
is_constructible<tuple<convertible, convertible>, int, int>(true)
));
#endif // !(gcc < 4.7)
BOOST_TEST((is_constructible<tuple<int, not_convertible>, int, int>(false)));
BOOST_TEST((is_constructible<tuple<not_convertible, int>, int, int>(false)));
BOOST_TEST((

95
test/support/unused.cpp Normal file
View File

@ -0,0 +1,95 @@
/*=============================================================================
Copyright (c) 2018 Kohei Takahashi
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 <boost/config.hpp>
#include <boost/fusion/support/unused.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/static_assert.hpp>
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
#include <utility>
#endif
struct T { };
void unused_construction()
{
boost::fusion::unused_type dephault;
boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED parenthesis();
#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED brace{};
boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED list_copy = {};
#endif
boost::fusion::unused_type copy_copy BOOST_ATTRIBUTE_UNUSED = dephault;
boost::fusion::unused_type copy_direct BOOST_ATTRIBUTE_UNUSED (dephault);
#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
boost::fusion::unused_type copy_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {dephault};
boost::fusion::unused_type copy_direct_brace BOOST_ATTRIBUTE_UNUSED {dephault};
#endif
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
boost::fusion::unused_type move_copy BOOST_ATTRIBUTE_UNUSED = std::move(dephault);
boost::fusion::unused_type move_direct BOOST_ATTRIBUTE_UNUSED (std::move(dephault));
#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
boost::fusion::unused_type move_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {std::move(dephault)};
boost::fusion::unused_type move_direct_brace BOOST_ATTRIBUTE_UNUSED {std::move(dephault)};
#endif
#endif
T value;
boost::fusion::unused_type T_copy_copy BOOST_ATTRIBUTE_UNUSED = value;
boost::fusion::unused_type T_copy_direct BOOST_ATTRIBUTE_UNUSED (value);
#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
boost::fusion::unused_type T_copy_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {value};
boost::fusion::unused_type T_copy_direct_brace BOOST_ATTRIBUTE_UNUSED {value};
#endif
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
boost::fusion::unused_type T_move_copy BOOST_ATTRIBUTE_UNUSED = std::move(value);
boost::fusion::unused_type T_move_direct BOOST_ATTRIBUTE_UNUSED (std::move(value));
#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
boost::fusion::unused_type T_move_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {std::move(value)};
boost::fusion::unused_type T_move_direct_brace BOOST_ATTRIBUTE_UNUSED {std::move(value)};
#endif
#endif
}
void unused_assignment()
{
boost::fusion::unused_type val1, val2;
val1 = val2;
#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
val1 = {};
#endif
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
val1 = std::move(val2);
#endif
T value;
val1 = value;
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
val1 = std::move(value);
#endif
}
boost::type_traits::yes_type test_unused(boost::fusion::detail::unused_only const&);
boost::type_traits::no_type test_unused(...);
void only_unused()
{
BOOST_STATIC_ASSERT((sizeof(test_unused(boost::fusion::unused)) == sizeof(boost::type_traits::yes_type)));
BOOST_STATIC_ASSERT((sizeof(test_unused(0)) == sizeof(boost::type_traits::no_type)));
boost::fusion::unused_type my_unused;
BOOST_STATIC_ASSERT((sizeof(test_unused(my_unused)) == sizeof(boost::type_traits::yes_type)));
}