algo: Added tests for mutable functor

to be able to call mutable object

.travis.yml

@@ -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
 

appveyor.yml

@@ -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%

include/boost/fusion/algorithm/iteration/detail/for_each.hpp

@@ -30,7 +30,7 @@ namespace detail
     template <typename First, typename Last, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_linear(First const& first, Last const& last, F const& f, mpl::false_)
+    for_each_linear(First const& first, Last const& last, F& f, mpl::false_)
     {
         f(*first);
         detail::for_each_linear(fusion::next(first), last, f, 
@@ -41,7 +41,7 @@ namespace detail
     template <typename Sequence, typename F, typename Tag>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_dispatch(Sequence& seq, F const& f, Tag)
+    for_each_dispatch(Sequence& seq, F& f, Tag)
     {
         detail::for_each_linear(
                                 fusion::begin(seq)
@@ -57,7 +57,7 @@ namespace detail
     {
         template<typename I0, typename F>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F const& f)
+        static void call(I0 const& i0, F& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -78,7 +78,7 @@ namespace detail
     {
         template<typename I0, typename F>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F const& f)
+        static void call(I0 const& i0, F& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -95,7 +95,7 @@ namespace detail
     {
         template<typename I0, typename F>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F const& f)
+        static void call(I0 const& i0, F& f)
         {
             f(*i0);
             typedef typename result_of::next<I0>::type I1;
@@ -109,7 +109,7 @@ namespace detail
     {
         template<typename I0, typename F>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static void call(I0 const& i0, F const& f)
+        static void call(I0 const& i0, F& f)
         {
             f(*i0);
         }
@@ -128,7 +128,7 @@ namespace detail
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each_dispatch(Sequence& seq, F const& f, random_access_traversal_tag)
+    for_each_dispatch(Sequence& seq, F& f, random_access_traversal_tag)
     {
         typedef typename result_of::begin<Sequence>::type begin;
         typedef typename result_of::end<Sequence>::type end;
@@ -138,7 +138,7 @@ namespace detail
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each(Sequence& seq, F const& f, mpl::false_) // unsegmented implementation
+    for_each(Sequence& seq, F& f, mpl::false_) // unsegmented implementation
     {
         detail::for_each_dispatch(seq, f, typename traits::category_of<Sequence>::type());
     }

include/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp

@@ -19,11 +19,11 @@ namespace boost { namespace fusion { namespace detail
     struct segmented_for_each_fun
     {
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        explicit segmented_for_each_fun(Fun const& f)
+        explicit segmented_for_each_fun(Fun& f)
           : fun(f)
         {}
 
-        Fun const& fun;
+        Fun& fun;
 
         template <typename Sequence, typename State, typename Context>
         struct apply
@@ -43,7 +43,7 @@ namespace boost { namespace fusion { namespace detail
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
     inline void
-    for_each(Sequence& seq, F const& f, mpl::true_) // segmented implementation
+    for_each(Sequence& seq, F& f, mpl::true_) // segmented implementation
     {
         fusion::segmented_fold_until(seq, void_(), segmented_for_each_fun<F>(f));
     }

include/boost/fusion/algorithm/iteration/for_each.hpp

@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2001-2007 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
+    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)
@@ -13,7 +14,7 @@
 #include <boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -28,24 +29,16 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence& seq, F const& f)
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence& seq, F f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
     }
 
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence const& seq, F const& f)
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence const& seq, F f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
     }

include/boost/fusion/algorithm/iteration/for_each_fwd.hpp

@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2011 Eric Niebler
+    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)
@@ -9,7 +10,7 @@
 
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -21,21 +22,13 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence& seq, F const& f);
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence& seq, F f);
 
     template <typename Sequence, typename F>
     BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
-    for_each(Sequence const& seq, F const& f);
+    inline typename enable_if<traits::is_sequence<Sequence> >::type
+    for_each(Sequence const& seq, F f);
 }}
 
 #endif

include/boost/fusion/container/deque/detail/keyed_element.hpp

@@ -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))
         {}

include/boost/fusion/container/list/cons.hpp

@@ -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) {}

include/boost/fusion/container/map/detail/map_impl.hpp

@@ -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;
 

include/boost/fusion/container/map/detail/value_at_key_impl.hpp

@@ -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;
             };
         };
     }

include/boost/fusion/container/vector/detail/value_at_impl.hpp

@@ -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;
             };
         };
     }

include/boost/fusion/support/category_of.hpp

@@ -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 <>

include/boost/fusion/support/config.hpp

@@ -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

include/boost/fusion/support/detail/and.hpp

@@ -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

include/boost/fusion/support/detail/category_of.hpp

@@ -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

include/boost/fusion/support/detail/is_mpl_sequence.hpp

@@ -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> >
     {};
 }}}

include/boost/fusion/support/detail/is_native_fusion_sequence.hpp

@@ -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

include/boost/fusion/support/detail/is_view.hpp

@@ -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

include/boost/fusion/support/detail/unknown_key.hpp

@@ -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

include/boost/fusion/support/is_sequence.hpp

@@ -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;
     }
 }}
 

include/boost/fusion/support/is_view.hpp

@@ -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 <>

include/boost/fusion/support/unused.hpp

@@ -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();

meta/explicit-failures-markup.xml

@@ -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,

test/Jamfile

@@ -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  ]
 

test/algorithm/all.cpp

@@ -1,11 +1,12 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
+    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/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/fusion/algorithm/query/all.hpp>
@@ -28,6 +29,19 @@ namespace
 
         int search;
     };
+
+    struct mutable_search_for : search_for
+    {
+        explicit mutable_search_for(int in_search)
+            : search_for(in_search)
+        {}
+
+        template <typename T>
+        bool operator()(T const& v)
+        {
+            return search_for::operator()(v);
+        }
+    };
 }
 
 int
@@ -58,11 +72,20 @@ main()
     }
 
     {
-        typedef boost::mpl::vector_c<int, 1> mpl_vec;
+        boost::fusion::vector<int, short, double> t(1, 2, 3.3);
+        BOOST_TEST(!boost::fusion::all(t, search_for(1)));
+        BOOST_TEST(!boost::fusion::all(t, mutable_search_for(1)));
+    }
+
+    {
+        typedef boost::mpl::vector_c<int, 1, 1, 1> mpl_vec;
         // We cannot use lambda here as mpl vec iterators return
         // rvalues, and lambda needs lvalues.
         BOOST_TEST(boost::fusion::all(mpl_vec(), search_for(1)));
         BOOST_TEST(!boost::fusion::all(mpl_vec(), search_for(2)));
+
+        BOOST_TEST(boost::fusion::all(mpl_vec(), mutable_search_for(1)));
+        BOOST_TEST(!boost::fusion::all(mpl_vec(), mutable_search_for(2)));
     }
 
     return boost::report_errors();

test/algorithm/any.cpp

@@ -2,11 +2,12 @@
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2005 Eric Niebler
     Copyright (c) Dan Marsden
+    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/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/fusion/algorithm/query/any.hpp>
@@ -29,6 +30,19 @@ namespace
 
         int search;
     };
+
+    struct mutable_search_for : search_for
+    {
+        explicit mutable_search_for(int in_search)
+            : search_for(in_search)
+        {}
+
+        template <typename T>
+        bool operator()(T const& v)
+        {
+            return search_for::operator()(v);
+        }
+    };
 }
 
 int
@@ -44,12 +58,21 @@ main()
         BOOST_TEST(!boost::fusion::any(t, boost::lambda::_1 == 3));
     }
 
+    {
+        boost::fusion::vector<int, short, double> t(1, 2, 3.3);
+        BOOST_TEST(boost::fusion::any(t, search_for(1)));
+        BOOST_TEST(boost::fusion::any(t, mutable_search_for(1)));
+    }
+
     {
         typedef boost::mpl::vector_c<int, 1, 2, 3> mpl_vec;
         // We cannot use lambda here as mpl vec iterators return
         // rvalues, and lambda needs lvalues.
         BOOST_TEST(boost::fusion::any(mpl_vec(), search_for(2)));
         BOOST_TEST(!boost::fusion::any(mpl_vec(), search_for(4)));
+
+        BOOST_TEST(boost::fusion::any(mpl_vec(), mutable_search_for(2)));
+        BOOST_TEST(!boost::fusion::any(mpl_vec(), mutable_search_for(4)));
     }
 
     return boost::report_errors();

test/algorithm/count_if.cpp

@@ -1,11 +1,12 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2005 Eric Niebler
+    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/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/fusion/algorithm/query/count_if.hpp>
@@ -18,20 +19,29 @@ struct bind1st<F<T> > : public F<T>
 {
     T n;
     bind1st(T n) : n(n) { }
+    bool operator()(T v) { return F<T>::operator()(n, v); }
     bool operator()(T v) const { return F<T>::operator()(n, v); }
 };
 
+template <typename T>
+struct mutable_equal_to : std::equal_to<T>
+{
+    bool operator()(T l, T r) { return std::equal_to<T>::operator()(l, r); }
+};
+
 int
 main()
 {
     {
         boost::fusion::vector<int, short, double> t(1, 2, 3.3);
         BOOST_TEST(boost::fusion::count_if(t, bind1st<std::equal_to<double> >(2)) == 1);
+        BOOST_TEST(boost::fusion::count_if(t, bind1st<mutable_equal_to<double> >(2)) == 1);
     }
 
     {
         boost::fusion::vector<int, short, double> t(1, 2, 3.3);
         BOOST_TEST(boost::fusion::count_if(t, bind1st<std::equal_to<double> >(3)) == 0);
+        BOOST_TEST(boost::fusion::count_if(t, bind1st<mutable_equal_to<double> >(3)) == 0);
     }
 
     {
@@ -39,6 +49,7 @@ main()
         // Cannot use lambda here as mpl iterators return rvalues and lambda needs lvalues
         BOOST_TEST(boost::fusion::count_if(mpl_vec(), bind1st<std::greater_equal<int> >(2)) == 2);
         BOOST_TEST(boost::fusion::count_if(mpl_vec(), bind1st<std::less<int> >(2)) == 1);
+        BOOST_TEST(boost::fusion::count_if(mpl_vec(), bind1st<mutable_equal_to<int> >(2)) == 1);
     }
 
     return boost::report_errors();

test/algorithm/fold.cpp

@@ -1,27 +1,25 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
+    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/detail/lightweight_test.hpp>
-#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
-#include <boost/fusion/sequence/io/out.hpp>
-#include <boost/fusion/sequence/intrinsic/at.hpp>
-#include <boost/fusion/container/generation/make_vector.hpp>
-#include <boost/fusion/algorithm/iteration/fold.hpp>
 #include <boost/fusion/algorithm/iteration/accumulate.hpp>
-#include <boost/type_traits/is_same.hpp>
+#include <boost/fusion/algorithm/iteration/fold.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
 #include <boost/mpl/if.hpp>
-#include <boost/mpl/next.hpp>
 #include <boost/mpl/int.hpp>
+#include <boost/mpl/next.hpp>
 #include <boost/mpl/vector.hpp>
-
+#include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/is_reference.hpp>
 
 #include <string>
 
@@ -130,7 +128,7 @@ struct functor
     }
 };
 
-struct visitor
+struct mutable_visitor
 {
     typedef int result_type;
 
@@ -248,7 +246,7 @@ main()
 
         {
             boost::fusion::vector<long> vec;
-            visitor v;
+            mutable_visitor v;
             boost::fusion::fold(vec, 0, v);
         }
     }

test/algorithm/for_each.cpp

@@ -1,13 +1,15 @@
 /*=============================================================================
     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)
 ==============================================================================*/
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
 #include <boost/fusion/algorithm/iteration/for_each.hpp>
 #include <boost/mpl/vector_c.hpp>
 
@@ -29,6 +31,15 @@ struct increment
     }
 };
 
+struct mutable_increment : increment
+{
+    template <typename T>
+    void operator()(T& v)
+    {
+        return increment::operator()(v);
+    }
+};
+
 int
 main()
 {
@@ -44,9 +55,20 @@ main()
     }
 
     {
+        char const ruby[] = "Ruby";
         typedef vector<int, char, double, char const*> vector_type;
-        vector_type v(1, 'x', 3.3, "Ruby");
+        vector_type v(1, 'x', 3.3, ruby);
         for_each(v, increment());
+        BOOST_TEST_EQ(v, vector_type(2, 'y', 4.3, ruby + 1));
+        std::cout << v << std::endl;
+    }
+
+    {
+        char const ruby[] = "Ruby";
+        typedef vector<int, char, double, char const*> vector_type;
+        vector_type v(1, 'x', 3.3, ruby);
+        for_each(v, mutable_increment());
+        BOOST_TEST_EQ(v, vector_type(2, 'y', 4.3, ruby + 1));
         std::cout << v << std::endl;
     }
 

test/algorithm/none.cpp

@@ -1,11 +1,12 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
+    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/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
 #include <boost/fusion/algorithm/query/none.hpp>
@@ -28,6 +29,19 @@ namespace
 
         int search;
     };
+
+    struct mutable_search_for : search_for
+    {
+        explicit mutable_search_for(int in_search)
+            : search_for(in_search)
+        {}
+
+        template <typename T>
+        bool operator()(T const& v)
+        {
+            return search_for::operator()(v);
+        }
+    };
 }
 
 int
@@ -45,12 +59,24 @@ main()
         BOOST_TEST((!boost::fusion::none(t, boost::lambda::_1 < 3)));
     }
 
+    {
+        boost::fusion::vector<int, short, double> t(1, 2, 3.3);
+        BOOST_TEST(!boost::fusion::none(t, search_for(1)));
+        BOOST_TEST(boost::fusion::none(t, search_for(3)));
+
+        BOOST_TEST(!boost::fusion::none(t, mutable_search_for(1)));
+        BOOST_TEST(boost::fusion::none(t, mutable_search_for(3)));
+    }
+
     {
         typedef boost::mpl::vector_c<int, 1, 2, 3> mpl_vec;
         // We cannot use lambda here as mpl vec iterators return
         // rvalues, and lambda needs lvalues.
         BOOST_TEST(boost::fusion::none(mpl_vec(), search_for(4)));
         BOOST_TEST(!boost::fusion::none(mpl_vec(), search_for(3)));
+
+        BOOST_TEST(boost::fusion::none(mpl_vec(), mutable_search_for(4)));
+        BOOST_TEST(!boost::fusion::none(mpl_vec(), mutable_search_for(3)));
     }
 
     return boost::report_errors();

test/algorithm/replace_if.cpp

@@ -1,19 +1,16 @@
 /*=============================================================================
     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)
 ==============================================================================*/
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
-#include <boost/fusion/adapted/mpl.hpp>
-#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/fusion/sequence/comparison/equal_to.hpp>
-#include <boost/fusion/sequence/intrinsic/at.hpp>
-#include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/algorithm/transformation/replace_if.hpp>
-#include <string>
 
 struct gt3
 {
@@ -24,6 +21,15 @@ struct gt3
     }
 };
 
+struct mutable_gt3 : gt3
+{
+    template <typename T>
+    bool operator()(T x)
+    {
+        return gt3::operator()(x);
+    }
+};
+
 int
 main()
 {
@@ -42,8 +48,18 @@ main()
 
         {
             std::cout << replace_if(t1, gt3(), -456) << std::endl;
-            BOOST_TEST((replace_if(t1, gt3(), -456)
-                == make_vector(1, 2, -456, -456, s, -456)));
+            BOOST_TEST_EQ(replace_if(t1, gt3(), -456), make_vector(1, 2, -456, -456, s, -456));
+        }
+    }
+
+    {
+        char const* s = "Ruby";
+        typedef vector<int, short, double, long, char const*, float> vector_type;
+        vector_type t1(1, 2, 3.3, 4, s, 5.5f);
+
+        {
+            std::cout << replace_if(t1, mutable_gt3(), -456) << std::endl;
+            BOOST_TEST_EQ(replace_if(t1, mutable_gt3(), -456), make_vector(1, 2, -456, -456, s, -456));
         }
     }
 

test/algorithm/segmented_for_each.cpp

@@ -1,14 +1,17 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2011 Eric Niebler
+    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/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
-#include <boost/fusion/algorithm/iteration/for_each.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
 #include "../sequence/tree.hpp"
 
 struct print
@@ -20,6 +23,31 @@ struct print
     }
 };
 
+struct increment
+{
+    template <typename T>
+    void operator()(T& v) const
+    {
+        ++v;
+    }
+};
+
+struct mutable_increment : increment
+{
+    template <typename T>
+    void operator()(T& v)
+    {
+        return increment::operator()(v);
+    }
+};
+
+template <typename F, typename Tree>
+void test(Tree tree, Tree const& expected)
+{
+    boost::fusion::for_each(tree, F());
+    BOOST_TEST_EQ(tree, expected);
+}
+
 int
 main()
 {
@@ -42,6 +70,69 @@ main()
             )
           , print()
         );
+        std::cout << std::endl;
+    }
+
+    {
+        test<increment>(
+            make_tree(
+                make_vector(double(0),'B')
+              , make_tree(
+                    make_vector(1,2,long(3))
+                  , make_tree(make_vector('a','b','c'))
+                  , make_tree(make_vector(short('d'),'e','f'))
+                )
+              , make_tree(
+                    make_vector(4,5,6)
+                  , make_tree(make_vector(float(1),'h','i'))
+                  , make_tree(make_vector('j','k','l'))
+                )
+            )
+          , make_tree(
+                make_vector(double(1),'C')
+              , make_tree(
+                    make_vector(2,3,long(4))
+                  , make_tree(make_vector('b','c','d'))
+                  , make_tree(make_vector(short('e'),'f','g'))
+                )
+              , make_tree(
+                    make_vector(5,6,7)
+                  , make_tree(make_vector(float(2),'i','j'))
+                  , make_tree(make_vector('k','l','m'))
+                )
+            )
+        );
+    }
+
+    {
+        test<mutable_increment>(
+            make_tree(
+                make_vector(double(0),'B')
+              , make_tree(
+                    make_vector(1,2,long(3))
+                  , make_tree(make_vector('a','b','c'))
+                  , make_tree(make_vector(short('d'),'e','f'))
+                )
+              , make_tree(
+                    make_vector(4,5,6)
+                  , make_tree(make_vector(float(1),'h','i'))
+                  , make_tree(make_vector('j','k','l'))
+                )
+            )
+          , make_tree(
+                make_vector(double(1),'C')
+              , make_tree(
+                    make_vector(2,3,long(4))
+                  , make_tree(make_vector('b','c','d'))
+                  , make_tree(make_vector(short('e'),'f','g'))
+                )
+              , make_tree(
+                    make_vector(5,6,7)
+                  , make_tree(make_vector(float(2),'i','j'))
+                  , make_tree(make_vector('k','l','m'))
+                )
+            )
+        );
     }
 
     return boost::report_errors();

test/sequence/define_struct_inline_move.cpp

@@ -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();
 }

test/sequence/define_tpl_struct_inline_move.cpp

@@ -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();
 }

test/sequence/github-176.cpp

@@ -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]> > >();
+}

test/sequence/hash.hpp

@@ -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));
 }

test/sequence/traits.hpp

@@ -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

test/sequence/tuple_traits.cpp

@@ -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((

test/support/unused.cpp

@@ -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 = boost::fusion::unused_type();
+#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)));
+}