[Boost-commit] svn:boost r74472 - trunk/libs/fusion/example/extension

Subject: [Boost-commit] svn:boost r74472 - trunk/libs/fusion/example/extension
From: joel_at_[hidden]
Date: 2011-09-19 21:41:40

Author: djowel
Date: 2011-09-19 21:41:38 EDT (Mon, 19 Sep 2011)
New Revision: 74472
URL: http://svn.boost.org/trac/boost/changeset/74472

Log:
const-correctness patch by Nathan Ridge.
Text files modified: 
   trunk/libs/fusion/example/extension/triple.cpp |   132 ++++++++++++++++++++++++++++----------- 
   1 files changed, 95 insertions(+), 37 deletions(-)

Modified: trunk/libs/fusion/example/extension/triple.cpp
==============================================================================
--- trunk/libs/fusion/example/extension/triple.cpp	(original)
+++ trunk/libs/fusion/example/extension/triple.cpp	2011-09-19 21:41:38 EDT (Mon, 19 Sep 2011)
@@ -1,8 +1,9 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2011 Nathan Ridge
     Copyright (c) 2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    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)
 ==============================================================================*/
 
@@ -17,11 +18,10 @@
 
 #include <boost/fusion/sequence/sequence_facade.hpp>
 #include <boost/fusion/iterator/iterator_facade.hpp>
-
 #include <boost/fusion/sequence/intrinsic.hpp>
 #include <boost/fusion/iterator.hpp>
-
 #include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/algorithm/iteration/fold.hpp>
 
 #include <boost/mpl/int.hpp>
 #include <boost/mpl/identity.hpp>
@@ -40,7 +40,8 @@
 {
     template<typename Seq, int N>
     struct triple_iterator
-        : fusion::iterator_facade<triple_iterator<Seq, N>, fusion::random_access_traversal_tag>
+        : fusion::iterator_facade<triple_iterator<Seq, N>,
+          fusion::random_access_traversal_tag>
     {
         typedef mpl::int_<N> index;
         typedef Seq sequence_type;
@@ -74,13 +75,19 @@
         template <typename Sq>
         struct deref<triple_iterator<Sq, 0> >
         {
-            typedef typename
-                mpl::if_<
-                    boost::is_const<Sq>
-                  , typename Sq::t0_type const&
-                  , typename Sq::t0_type&
-                >::type
-            type;
+            typedef typename Sq::t0_type& type;
+
+            static type
+            call(triple_iterator<Sq, 0> const& iter)
+            {
+                return iter.seq_.t0;
+            }
+        };
+
+        template <typename Sq>
+        struct deref<triple_iterator<Sq, 0> const>
+        {
+            typedef typename Sq::t0_type const& type;
 
             static type
             call(triple_iterator<Sq, 0> const& iter)
@@ -92,13 +99,19 @@
         template <typename Sq>
         struct deref<triple_iterator<Sq, 1> >
         {
-            typedef typename
-                mpl::if_<
-                    boost::is_const<Sq>
-                  , typename Sq::t1_type const&
-                  , typename Sq::t1_type&
-                >::type
-            type;
+            typedef typename Sq::t1_type& type;
+
+            static type
+            call(triple_iterator<Sq, 1> const& iter)
+            {
+                return iter.seq_.t1;
+            }
+        };
+
+        template <typename Sq>
+        struct deref<triple_iterator<Sq, 1> const>
+        {
+            typedef typename Sq::t1_type const& type;
 
             static type
             call(triple_iterator<Sq, 1> const& iter)
@@ -110,13 +123,19 @@
         template <typename Sq>
         struct deref<triple_iterator<Sq, 2> >
         {
-            typedef typename
-                mpl::if_<
-                    boost::is_const<Sq>
-                  , typename Sq::t2_type const&
-                  , typename Sq::t2_type&
-                >::type
-            type;
+            typedef typename Sq::t2_type& type;
+
+            static type
+            call(triple_iterator<Sq, 2> const& iter)
+            {
+                return iter.seq_.t2;
+            }
+        };
+
+        template <typename Sq>
+        struct deref<triple_iterator<Sq, 2> const>
+        {
+            typedef typename Sq::t2_type const& type;
 
             static type
             call(triple_iterator<Sq, 2> const& iter)
@@ -129,7 +148,8 @@
         struct next
         {
             typedef triple_iterator<
-                typename It::sequence_type, It::index::value + 1> type;
+                typename It::sequence_type, It::index::value + 1>
+            type;
 
             static type call(It const& it)
             {
@@ -141,7 +161,8 @@
         struct prior
         {
             typedef triple_iterator<
-                typename It::sequence_type, It::index::value - 1> type;
+                typename It::sequence_type, It::index::value - 1>
+            type;
 
             static type call(It const& it)
             {
@@ -152,7 +173,9 @@
         template<typename It1, typename It2>
         struct distance
         {
-            typedef typename mpl::minus<typename It2::index, typename It1::index>::type type;
+            typedef typename mpl::minus<
+              typename It2::index, typename It1::index>::type
+            type;
 
             static type call(It1 const& it1, It2 const& it2)
             {
@@ -165,7 +188,8 @@
         {
             typedef triple_iterator<
                 typename It::sequence_type,
-                It::index::value + M::value> type;
+                It::index::value + M::value>
+            type;
 
             static type call(It const& it)
             {
@@ -176,7 +200,8 @@
 
     template<typename T0, typename T1, typename T2>
     struct triple
-        : fusion::sequence_facade<triple<T0, T1, T2>, fusion::random_access_traversal_tag>
+        : fusion::sequence_facade<triple<T0, T1, T2>,
+          fusion::random_access_traversal_tag>
     {
         triple(T0 const& t0, T1 const& t1, T2 const& t2)
             : t0(t0), t1(t1), t2(t2)
@@ -185,8 +210,7 @@
         template<typename Sq>
         struct begin
         {
-            typedef demo::triple_iterator<
-                Sq, 0> type;
+            typedef demo::triple_iterator<Sq, 0> type;
 
             static type call(Sq& sq)
             {
@@ -197,8 +221,7 @@
         template<typename Sq>
         struct end
         {
-            typedef demo::triple_iterator<
-                Sq, 3> type;
+            typedef demo::triple_iterator<Sq, 3> type;
 
             static type call(Sq& sq)
             {
@@ -300,6 +323,36 @@
     };
 }
 
+struct modifying_fold_functor
+{
+    template <typename T>
+    struct result
+    {
+        typedef bool type;
+    };
+
+    template <typename T>
+    bool operator()(bool b, T&)
+    {
+        return b;
+    }
+};
+
+struct nonmodifying_fold_functor
+{
+    template <typename T>
+    struct result
+    {
+        typedef bool type;
+    };
+
+    template <typename T>
+    bool operator()(bool b, const T&)
+    {
+        return b;
+    }
+};
+
 int main()
 {
     typedef demo::triple<int, char, std::string> my_triple;
@@ -309,11 +362,16 @@
     BOOST_TEST(*fusion::prior(fusion::end(t)) == "hello");
     BOOST_TEST(fusion::distance(fusion::begin(t), fusion::end(t)) == 3);
     BOOST_TEST(fusion::size(t) == 3);
-    BOOST_MPL_ASSERT((boost::is_same<int, fusion::result_of::value_at_c<my_triple, 0>::type>));
-    BOOST_MPL_ASSERT((boost::is_same<char, fusion::result_of::value_at_c<my_triple, 1>::type>));
-    BOOST_MPL_ASSERT((boost::is_same<std::string, fusion::result_of::value_at_c<my_triple, 2>::type>));
+    BOOST_MPL_ASSERT((boost::is_same<
+        int, fusion::result_of::value_at_c<my_triple, 0>::type>));
+    BOOST_MPL_ASSERT((boost::is_same<
+      char, fusion::result_of::value_at_c<my_triple, 1>::type>));
+    BOOST_MPL_ASSERT((boost::is_same<
+        std::string, fusion::result_of::value_at_c<my_triple, 2>::type>));
     BOOST_TEST(fusion::at_c<0>(t) == 101);
     BOOST_TEST(fusion::at_c<1>(t) == 'a');
     BOOST_TEST(fusion::at_c<2>(t) == "hello");
+    BOOST_TEST(fusion::fold(t, true, modifying_fold_functor()) == true);
+    BOOST_TEST(fusion::fold(t, true, nonmodifying_fold_functor()) == true);
     return boost::report_errors();
 }