Clean up GCC warnings. Fixes #3033.

[SVN r62869]

include/boost/fusion/view/filter_view/filter_view.hpp

@@ -45,8 +45,8 @@ namespace boost { namespace fusion
         typedef typename result_of::end<Sequence>::type last_type;
         typedef Pred pred_type;
 
-        filter_view(Sequence& seq)
-            : seq(seq)
+        filter_view(Sequence& in_seq)
+            : seq(in_seq)
         {}
 
         first_type first() const { return fusion::begin(seq); }

include/boost/fusion/view/filter_view/filter_view_iterator.hpp

@@ -54,8 +54,8 @@ namespace boost { namespace fusion
         typedef last_iter last_type;
         typedef Pred pred_type;
 
-        filter_iterator(First const& first)
-            : first(filter::call(first_converter::call(first))) {}
+        filter_iterator(First const& in_first)
+            : first(filter::call(first_converter::call(in_first))) {}
 
         first_type first;
 

include/boost/fusion/view/iterator_range/iterator_range.hpp

@@ -41,9 +41,9 @@ namespace boost { namespace fusion
 
         typedef typename traits::category_of<begin_type>::type category;
 
-        iterator_range(First const& first, Last const& last)
-            : first(convert_iterator<First>::call(first))
-            , last(convert_iterator<Last>::call(last)) {}
+        iterator_range(First const& in_first, Last const& in_last)
+            : first(convert_iterator<First>::call(in_first))
+            , last(convert_iterator<Last>::call(in_last)) {}
 
         begin_type first;
         end_type last;

include/boost/fusion/view/joint_view/joint_view.hpp

@@ -52,9 +52,9 @@ namespace boost { namespace fusion
         typedef typename result_of::end<Sequence2>::type concat_last_type;
         typedef typename mpl::plus<result_of::size<Sequence1>, result_of::size<Sequence2> >::type size;
 
-        joint_view(Sequence1& seq1, Sequence2& seq2)
-            : seq1(seq1)
-            , seq2(seq2)
+        joint_view(Sequence1& in_seq1, Sequence2& in_seq2)
+            : seq1(in_seq1)
+            , seq2(in_seq2)
         {}
 
         first_type first() const { return fusion::begin(seq1); }

include/boost/fusion/view/joint_view/joint_view_iterator.hpp

@@ -40,9 +40,9 @@ namespace boost { namespace fusion
         typedef Category category;
         BOOST_STATIC_ASSERT((!result_of::equal_to<first_type, last_type>::value));
 
-        joint_view_iterator(First const& first, Concat const& concat)
-            : first(first_converter::call(first))
-            , concat(concat_converter::call(concat))
+        joint_view_iterator(First const& in_first, Concat const& in_concat)
+            : first(first_converter::call(in_first))
+            , concat(concat_converter::call(in_concat))
         {}
 
         first_type first;

include/boost/fusion/view/nview/nview_iterator.hpp

@@ -41,8 +41,8 @@ namespace boost { namespace fusion
         typedef Sequence sequence_type;
         typedef mpl_iterator<Pos> first_type;
 
-        explicit nview_iterator(Sequence& seq)
-          : seq(seq) {}
+        explicit nview_iterator(Sequence& in_seq)
+          : seq(in_seq) {}
 
         Sequence& seq;
 

include/boost/fusion/view/repetitive_view/repetitive_view.hpp

@@ -37,8 +37,8 @@ namespace boost { namespace fusion
             mpl::if_<traits::is_view<Sequence>, Sequence, sequence_type&>::type
         stored_seq_type;
 
-        repetitive_view(Sequence& seq)
-            : seq(seq) {}
+        repetitive_view(Sequence& in_seq)
+            : seq(in_seq) {}
 
         stored_seq_type seq;
 

include/boost/fusion/view/repetitive_view/repetitive_view_iterator.hpp

@@ -35,11 +35,11 @@ namespace boost { namespace fusion
         typedef typename convert_iterator<typename result_of::end<Sequence>::type>::type end_type;
         typedef single_pass_traversal_tag category;
 
-        explicit repetitive_view_iterator(Sequence& seq)
-            : seq(seq), pos(begin(seq)) {}
+        explicit repetitive_view_iterator(Sequence& in_seq)
+            : seq(in_seq), pos(begin(in_seq)) {}
 
-        repetitive_view_iterator(Sequence& seq, pos_type const& pos)
-            : seq(seq), pos(pos) {}
+        repetitive_view_iterator(Sequence& in_seq, pos_type const& in_pos)
+            : seq(in_seq), pos(in_pos) {}
 
         Sequence& seq;
         pos_type pos;

include/boost/fusion/view/reverse_view/reverse_view.hpp

@@ -49,8 +49,8 @@ namespace boost { namespace fusion
                 bidirectional_traversal_tag
               , typename traits::category_of<first_type>::type>::value));
 
-        reverse_view(Sequence& seq)
-            : seq(seq)
+        reverse_view(Sequence& in_seq)
+            : seq(in_seq)
         {}
 
         first_type first() const { return fusion::begin(seq); }

include/boost/fusion/view/reverse_view/reverse_view_iterator.hpp

@@ -41,8 +41,8 @@ namespace boost { namespace fusion
                 bidirectional_traversal_tag
               , category>::value));
 
-        reverse_view_iterator(First const& first)
-            : first(converter::call(first)) {}
+        reverse_view_iterator(First const& in_first)
+            : first(converter::call(in_first)) {}
 
         first_type first;
 

include/boost/fusion/view/single_view/single_view.hpp

@@ -41,8 +41,8 @@ namespace boost { namespace fusion
         single_view()
             : val() {}
 
-        explicit single_view(typename detail::call_param<T>::type val)
-            : val(val) {}
+        explicit single_view(typename detail::call_param<T>::type in_val)
+            : val(in_val) {}
 
         value_type val;
     };

include/boost/fusion/view/transform_view/transform_view.hpp

@@ -55,10 +55,10 @@ namespace boost { namespace fusion
         typedef Sequence2 sequence2_type;
         typedef F transform_type;
 
-        transform_view(Sequence1& seq1, Sequence2& seq2, F const& binop)
+        transform_view(Sequence1& in_seq1, Sequence2& in_seq2, F const& binop)
             : f(binop)
-            , seq1(seq1)
-            , seq2(seq2)
+            , seq1(in_seq1)
+            , seq2(in_seq2)
         {}
 
         first1_type first1() const { return fusion::begin(seq1); }
@@ -94,9 +94,9 @@ namespace boost { namespace fusion
         typedef Sequence sequence_type;
         typedef F transform_type;
 
-        transform_view(Sequence& seq, F const& f)
-            : seq(seq)
-            , f(f)
+        transform_view(Sequence& in_seq, F const& in_f)
+            : seq(in_seq)
+            , f(in_f)
         {}
 
         first_type first() const { return fusion::begin(seq); }

include/boost/fusion/view/transform_view/transform_view_iterator.hpp

@@ -34,8 +34,8 @@ namespace boost { namespace fusion
         typedef typename traits::category_of<first_type>::type category;
         typedef F transform_type;
 
-        transform_view_iterator(First const& first, F const& f)
-            : first(converter::call(first)), f(f) {}
+        transform_view_iterator(First const& in_first, F const& in_f)
+            : first(converter::call(in_first)), f(in_f) {}
 
         first_type first;
         transform_type f;
@@ -60,8 +60,8 @@ namespace boost { namespace fusion
         typedef typename traits::category_of<first1_type>::type category;
         typedef F transform_type;
 
-        transform_view_iterator2(First1 const& first1, First2 const& first2, F const& f)
-            : first1(converter1::call(first1)), first2(converter2::call(first2)), f(f) {}
+        transform_view_iterator2(First1 const& in_first1, First2 const& in_first2, F const& in_f)
+            : first1(converter1::call(in_first1)), first2(converter2::call(in_first2)), f(in_f) {}
 
         first1_type first1;
         first2_type first2;