Ticket #7991: patch_sebastien_gilles_110213.patch

File patch_sebastien_gilles_110213.patch, 31.6 KB (added by sgilles, 10 years ago)

New patch that also corrects -Wshadow warnings

  • boost/concept_check.hpp 

    Only in Boost: b2
Only in Boost: bin.v2
Only in Boost: bjam
Only in Boost/boost: .DS_Store
diff -dur boost_1_53_0/boost/concept_check.hpp Boost/boost/concept_check.hpp
    old new  
    880880          typename BackInsertionSequence::const_reference
    881881              r = cc.back();
    882882          ignore_unused_variable_warning(r);
    883       };
     883      }
    884884      S c;
    885885      typename S::value_type t;
    886886  };

  • boost/function/function_base.hpp 

    diff -dur boost_1_53_0/boost/function/function_base.hpp Boost/boost/function/function_base.hpp
    old new  
    435435            out_buffer.type.const_qualified = false;
    436436            out_buffer.type.volatile_qualified = false;
    437437            return;
     438                 
     439          case clone_functor_tag:
     440          case move_functor_tag:
     441          case destroy_functor_tag:
     442          case check_functor_type_tag:
    438443
    439           default:
    440444            manager(in_buffer, out_buffer, op, tag_type());
    441445            return;
    442446          }
    … …  
    539543            out_buffer.type.volatile_qualified = false;
    540544            return;
    541545
    542           default:
     546          case clone_functor_tag:
     547          case move_functor_tag:
     548          case destroy_functor_tag:
     549          case check_functor_type_tag:
    543550            manager(in_buffer, out_buffer, op, tag_type());
    544551            return;
    545552          }

  • boost/lexical_cast.hpp 

    diff -dur boost_1_53_0/boost/lexical_cast.hpp Boost/boost/lexical_cast.hpp
    old new  
    22252225                > interpreter_type;
    22262226
    22272227                // Target type must be default constructible
    2228                 Target result;               
     2228                Target result = Target();
    22292229
    22302230                BOOST_DEDUCED_TYPENAME stream_trait::char_type buf[stream_trait::len_t::value + 1];
    22312231                stream_trait::len_t::check_coverage();

  • boost/numeric/ublas/detail/iterator.hpp 

    Only in Boost/boost/numeric: .DS_Store
Only in Boost/boost/numeric/ublas: .DS_Store
diff -dur boost_1_53_0/boost/numeric/ublas/detail/iterator.hpp Boost/boost/numeric/ublas/detail/iterator.hpp
    old new  
    2222  /** \brief Base class of all proxy classes that contain
    2323   *       a (redirectable) reference to an immutable object.
    2424   *
    25    *       \param C the type of the container referred to
     25   *       \tparam C the type of the container referred to
    2626   */
    2727    template<class C>
    2828    class container_const_reference:
    … …  
    6161  /** \brief Base class of all proxy classes that contain
    6262   *         a (redirectable) reference to a mutable object.
    6363   *
    64    * \param C the type of the container referred to
     64   * \tparam C the type of the container referred to
    6565   */
    6666    template<class C>
    6767    class container_reference:
    … …  
    9999
    100100  /** \brief Base class of all forward iterators.
    101101   *
    102    *  \param IC the iterator category
    103    *  \param I the derived iterator type
    104    *  \param T the value type
     102   *  \tparam IC the iterator category
     103   *  \tparam I the derived iterator type
     104   *  \tparam T the value type
    105105   *
    106106   * The forward iterator can only proceed in one direction
    107107   * via the post increment operator.
    … …  
    137137
    138138  /** \brief Base class of all bidirectional iterators.
    139139   *
    140    * \param IC the iterator category
    141    * \param I the derived iterator type
    142    * \param T the value type
     140   * \tparam IC the iterator category
     141   * \tparam I the derived iterator type
     142   * \tparam T the value type
    143143   *
    144144   * The bidirectional iterator can proceed in both directions
    145145   * via the post increment and post decrement operator.
    … …  
    188188
    189189  /** \brief Base class of all random access iterators.
    190190   *
    191    * \param IC the iterator category
    192    * \param I the derived iterator type
    193    * \param T the value type
    194    * \param D the difference type, default: std::ptrdiff_t
     191   * \tparam IC the iterator category
     192   * \tparam I the derived iterator type
     193   * \tparam T the value type
     194   * \tparam D the difference type, default: std::ptrdiff_t
    195195   *
    196196   * The random access iterator can proceed in both directions
    197197   * via the post increment/decrement operator or in larger steps
    … …  
    293293
    294294  /** \brief Base class of all reverse iterators. (non-MSVC version)
    295295   *
    296    * \param I the derived iterator type
    297    * \param T the value type
    298    * \param R the reference type
     296   * \tparam I the derived iterator type
    299297   *
    300298   * The reverse iterator implements a bidirectional iterator
    301299   * reversing the elements of the underlying iterator. It
    … …  
    388386
    389387  /** \brief 1st base class of all matrix reverse iterators. (non-MSVC version)
    390388   *
    391    * \param I the derived iterator type
     389   * \tparam I the derived iterator type
    392390   *
    393391   * The reverse iterator implements a bidirectional iterator
    394392   * reversing the elements of the underlying iterator. It
    … …  
    508506
    509507  /** \brief 2nd base class of all matrix reverse iterators. (non-MSVC version)
    510508   *
    511    * \param I the derived iterator type
     509   * \tparam I the derived iterator type
    512510   *
    513511   * The reverse iterator implements a bidirectional iterator
    514512   * reversing the elements of the underlying iterator. It
    … …  
    630628
    631629  /** \brief A class implementing an indexed random access iterator.
    632630   *
    633    * \param C the (mutable) container type
    634    * \param IC the iterator category
     631   * \tparam C the (mutable) container type
     632   * \tparam IC the iterator category
    635633   *
    636634   * This class implements a random access iterator. The current
    637635   * position is stored as the unsigned integer it_ and the
    … …  
    735733
    736734  /** \brief A class implementing an indexed random access iterator.
    737735   *
    738    * \param C the (immutable) container type
    739    * \param IC the iterator category
     736   * \tparam C the (immutable) container type
     737   * \tparam IC the iterator category
    740738   *
    741739   * This class implements a random access iterator. The current
    742740   * position is stored as the unsigned integer \c it_ and the
    … …  
    853851  /** \brief A class implementing an indexed random access iterator
    854852   * of a matrix.
    855853   *
    856    * \param C the (mutable) container type
    857    * \param IC the iterator category
     854   * \tparam C the (mutable) container type
     855   * \tparam IC the iterator category
    858856   *
    859857   * This class implements a random access iterator. The current
    860858   * position is stored as two unsigned integers \c it1_ and \c it2_
    … …  
    997995  /** \brief A class implementing an indexed random access iterator
    998996   * of a matrix.
    999997   *
    1000    * \param C the (immutable) container type
    1001    * \param IC the iterator category
     998   * \tparam C the (immutable) container type
     999   * \tparam IC the iterator category
    10021000   *
    10031001   * This class implements a random access iterator. The current
    10041002   * position is stored as two unsigned integers \c it1_ and \c it2_
    … …  
    11461144  /** \brief A class implementing an indexed random access iterator
    11471145   * of a matrix.
    11481146   *
    1149    * \param C the (mutable) container type
    1150    * \param IC the iterator category
     1147   * \tparam C the (mutable) container type
     1148   * \tparam IC the iterator category
    11511149   *
    11521150   * This class implements a random access iterator. The current
    11531151   * position is stored as two unsigned integers \c it1_ and \c it2_
    … …  
    12851283  /** \brief A class implementing an indexed random access iterator
    12861284   * of a matrix.
    12871285   *
    1288    * \param C the (immutable) container type
    1289    * \param IC the iterator category
     1286   * \tparam C the (immutable) container type
     1287   * \tparam IC the iterator category
    12901288   *
    12911289   * This class implements a random access iterator. The current
    12921290   * position is stored as two unsigned integers \c it1_ and \c it2_

  • boost/numeric/ublas/detail/matrix_assign.hpp 

    diff -dur boost_1_53_0/boost/numeric/ublas/detail/matrix_assign.hpp Boost/boost/numeric/ublas/detail/matrix_assign.hpp
    old new  
    7575                if (it2 != it2_end && it2e != it2e_end) {
    7676                    size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
    7777                    while (true) {
    78                         difference_type compare = it2_index - it2e_index;
    79                         if (compare == 0) {
     78                        difference_type compare2 = it2_index - it2e_index;
     79                        if (compare2 == 0) {
    8080                            ++ it2, ++ it2e;
    8181                            if (it2 != it2_end && it2e != it2e_end) {
    8282                                it2_index = it2.index2 ();
    8383                                it2e_index = it2e.index2 ();
    8484                            } else
    8585                                break;
    86                         } else if (compare < 0) {
    87                             increment (it2, it2_end, - compare);
     86                        } else if (compare2 < 0) {
     87                            increment (it2, it2_end, - compare2);
    8888                            if (it2 != it2_end)
    8989                                it2_index = it2.index2 ();
    9090                            else
    9191                                break;
    92                         } else if (compare > 0) {
     92                        } else if (compare2 > 0) {
    9393                            if (conformant_restrict_type::other (it2e.index1 (), it2e.index2 ()))
    9494                                if (static_cast<value_type>(*it2e) != value_type/*zero*/())
    9595                                    index.push_back (std::pair<size_type, size_type> (it2e.index1 (), it2e.index2 ()));
    … …  
    178178                if (it1 != it1_end && it1e != it1e_end) {
    179179                    size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
    180180                    while (true) {
    181                         difference_type compare = it1_index - it1e_index;
    182                         if (compare == 0) {
     181                        difference_type compare2 = it1_index - it1e_index;
     182                        if (compare2 == 0) {
    183183                            ++ it1, ++ it1e;
    184184                            if (it1 != it1_end && it1e != it1e_end) {
    185185                                it1_index = it1.index1 ();
    186186                                it1e_index = it1e.index1 ();
    187187                            } else
    188188                                break;
    189                         } else if (compare < 0) {
    190                             increment (it1, it1_end, - compare);
     189                        } else if (compare2 < 0) {
     190                            increment (it1, it1_end, - compare2);
    191191                            if (it1 != it1_end)
    192192                                it1_index = it1.index1 ();
    193193                            else
    194194                                break;
    195                         } else if (compare > 0) {
     195                        } else if (compare2 > 0) {
    196196                            if (conformant_restrict_type::other (it1e.index1 (), it1e.index2 ()))
    197197                                if (static_cast<value_type>(*it1e) != value_type/*zero*/())
    198198                                    index.push_back (std::pair<size_type, size_type> (it1e.index1 (), it1e.index2 ()));
    … …  
    997997                if (it2 != it2_end && it2e != it2e_end) {
    998998                    size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
    999999                    while (true) {
    1000                         difference_type compare = it2_index - it2e_index;
    1001                         if (compare == 0) {
     1000                        difference_type compare2 = it2_index - it2e_index;
     1001                        if (compare2 == 0) {
    10021002                            functor_type::apply (*it2, *it2e);
    10031003                            ++ it2, ++ it2e;
    10041004                            if (it2 != it2_end && it2e != it2e_end) {
    … …  
    10061006                                it2e_index = it2e.index2 ();
    10071007                            } else
    10081008                                break;
    1009                         } else if (compare < 0) {
     1009                        } else if (compare2 < 0) {
    10101010                            if (!functor_type::computed) {
    10111011                                functor_type::apply (*it2, expr_value_type/*zero*/());
    10121012                                ++ it2;
    10131013                            } else
    1014                                 increment (it2, it2_end, - compare);
     1014                                increment (it2, it2_end, - compare2);
    10151015                            if (it2 != it2_end)
    10161016                                it2_index = it2.index2 ();
    10171017                            else
    10181018                                break;
    1019                         } else if (compare > 0) {
    1020                             increment (it2e, it2e_end, compare);
     1019                        } else if (compare2 > 0) {
     1020                            increment (it2e, it2e_end, compare2);
    10211021                            if (it2e != it2e_end)
    10221022                                it2e_index = it2e.index2 ();
    10231023                            else
    … …  
    11181118                if (it1 != it1_end && it1e != it1e_end) {
    11191119                    size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
    11201120                    while (true) {
    1121                         difference_type compare = it1_index - it1e_index;
    1122                         if (compare == 0) {
     1121                        difference_type compare2 = it1_index - it1e_index;
     1122                        if (compare2 == 0) {
    11231123                            functor_type::apply (*it1, *it1e);
    11241124                            ++ it1, ++ it1e;
    11251125                            if (it1 != it1_end && it1e != it1e_end) {
    … …  
    11271127                                it1e_index = it1e.index1 ();
    11281128                            } else
    11291129                                break;
    1130                         } else if (compare < 0) {
     1130                        } else if (compare2 < 0) {
    11311131                            if (!functor_type::computed) {
    11321132                                functor_type::apply (*it1, expr_value_type/*zero*/()); // zeroing
    11331133                                ++ it1;
    11341134                            } else
    1135                                 increment (it1, it1_end, - compare);
     1135                                increment (it1, it1_end, - compare2);
    11361136                            if (it1 != it1_end)
    11371137                                it1_index = it1.index1 ();
    11381138                            else
    11391139                                break;
    1140                         } else if (compare > 0) {
    1141                             increment (it1e, it1e_end, compare);
     1140                        } else if (compare2 > 0) {
     1141                            increment (it1e, it1e_end, compare2);
    11421142                            if (it1e != it1e_end)
    11431143                                it1e_index = it1e.index1 ();
    11441144                            else
    … …  
    13861386                if (it2 != it2_end && it2e != it2e_end) {
    13871387                    size_type it2_index = it2.index2 (), it2e_index = it2e.index2 ();
    13881388                    while (true) {
    1389                         difference_type compare = it2_index - it2e_index;
    1390                         if (compare == 0) {
     1389                        difference_type compare2 = it2_index - it2e_index;
     1390                        if (compare2 == 0) {
    13911391                            functor_type::apply (*it2, *it2e);
    13921392                            ++ it2, ++ it2e;
    13931393                            if (it2 != it2_end && it2e != it2e_end) {
    … …  
    13951395                                it2e_index = it2e.index2 ();
    13961396                            } else
    13971397                                break;
    1398                         } else if (compare < 0) {
    1399                             increment (it2, it2_end, - compare);
     1398                        } else if (compare2 < 0) {
     1399                            increment (it2, it2_end, - compare2);
    14001400                            if (it2 != it2_end)
    14011401                                it2_index = it2.index2 ();
    14021402                            else
    14031403                                break;
    1404                         } else if (compare > 0) {
    1405                             increment (it2e, it2e_end, compare);
     1404                        } else if (compare2 > 0) {
     1405                            increment (it2e, it2e_end, compare2);
    14061406                            if (it2e != it2e_end)
    14071407                                it2e_index = it2e.index2 ();
    14081408                            else
    … …  
    15111511                if (it1 != it1_end && it1e != it1e_end) {
    15121512                    size_type it1_index = it1.index1 (), it1e_index = it1e.index1 ();
    15131513                    while (true) {
    1514                         difference_type compare = it1_index - it1e_index;
    1515                         if (compare == 0) {
     1514                        difference_type compare2 = it1_index - it1e_index;
     1515                        if (compare2 == 0) {
    15161516                            functor_type::apply (*it1, *it1e);
    15171517                            ++ it1, ++ it1e;
    15181518                            if (it1 != it1_end && it1e != it1e_end) {
    … …  
    15201520                                it1e_index = it1e.index1 ();
    15211521                            } else
    15221522                                break;
    1523                         }  else if (compare < 0) {
    1524                             increment (it1, it1_end, - compare);
     1523                        }  else if (compare2 < 0) {
     1524                            increment (it1, it1_end, - compare2);
    15251525                            if (it1 != it1_end)
    15261526                                it1_index = it1.index1 ();
    15271527                            else
    15281528                                break;
    1529                         } else if (compare > 0) {
    1530                             increment (it1e, it1e_end, compare);
     1529                        } else if (compare2 > 0) {
     1530                            increment (it1e, it1e_end, compare2);
    15311531                            if (it1e != it1e_end)
    15321532                                it1e_index = it1e.index1 ();
    15331533                            else

  • boost/numeric/ublas/lu.hpp 

    diff -dur boost_1_53_0/boost/numeric/ublas/lu.hpp Boost/boost/numeric/ublas/lu.hpp
    old new  
    2323
    2424namespace boost { namespace numeric { namespace ublas {
    2525
    26     /** \brief
     26    /** \brief ???
    2727     *
    28      * \tparam T
    29      * \tparam A
     28     * \tparam T ???
     29     * \tparam A ???
    3030     */
    3131    template<class T = std::size_t, class A = unbounded_array<T> >
    3232    class permutation_matrix:

  • boost/numeric/ublas/matrix_proxy.hpp 

    diff -dur boost_1_53_0/boost/numeric/ublas/matrix_proxy.hpp Boost/boost/numeric/ublas/matrix_proxy.hpp
    old new  
    2222
    2323namespace boost { namespace numeric { namespace ublas {
    2424
    25     /** \brief
     25    /** \brief ???
    2626     */
    2727    template<class M>
    2828    class matrix_row:
    … …  
    41794179     * falls outside that of the indices of the matrix, then the \c matrix_indirect is not a well formed
    41804180     * \i Matrix \i Expression and access to an element outside of indices of the matrix is \b undefined.
    41814181     *
    4182      * \tparam V the type of the referenced matrix, for example \c matrix<double>)
    41834182     * \tparam IA the type of index matrix. Default is \c ublas::indirect_array<>
    41844183     */
    41854184    template<class M, class IA>

  • boost/numeric/ublas/operation.hpp 

    diff -dur boost_1_53_0/boost/numeric/ublas/operation.hpp Boost/boost/numeric/ublas/operation.hpp
    old new  
    234234          \internal
    235235         
    236236          template parameters:
    237           \param V type of the result vector \c v
    238           \param E1 type of a matrix expression \c A
    239           \param E2 type of a vector expression \c x
     237          \tparam V type of the result vector \c v
     238          \tparam E1 type of a matrix expression \c A
     239          \tparam E2 type of a vector expression \c x
    240240  */
    241241    template<class V, class E1, class E2>
    242242    BOOST_UBLAS_INLINE
    … …  
    456456          \internal
    457457         
    458458          template parameters:
    459           \param V type of the result vector \c v
    460           \param E1 type of a vector expression \c x
    461           \param E2 type of a matrix expression \c A
     459          \tparam V type of the result vector \c v
     460          \tparam E1 type of a vector expression \c x
     461          \tparam E2 type of a matrix expression \c A
    462462  */
    463463    template<class V, class E1, class E2>
    464464    BOOST_UBLAS_INLINE
    … …  
    701701          \internal
    702702         
    703703          template parameters:
    704           \param M type of the result matrix \c M
    705           \param E1 type of a matrix expression \c A
    706           \param E2 type of a matrix expression \c X
     704          \tparam M type of the result matrix \c M
     705          \tparam E1 type of a matrix expression \c A
     706          \tparam E2 type of a matrix expression \c X
    707707  */
    708708    template<class M, class E1, class E2>
    709709    BOOST_UBLAS_INLINE
    … …  
    817817          \internal
    818818         
    819819          template parameters:
    820           \param M type of the result matrix \c M
    821           \param E1 type of a matrix expression \c A
    822           \param E2 type of a matrix expression \c X
     820          \tparam M type of the result matrix \c M
     821          \tparam E1 type of a matrix expression \c A
     822          \tparam E2 type of a matrix expression \c X
    823823  */
    824824    template<class M, class E1, class E2>
    825825    BOOST_UBLAS_INLINE

  • boost/numeric/ublas/storage.hpp 

    diff -dur boost_1_53_0/boost/numeric/ublas/storage.hpp Boost/boost/numeric/ublas/storage.hpp
    old new  
    128128                            }
    129129                        }
    130130                        else {
    131                             for (pointer si = p_data; si != p_data + size_; ++si) {
    132                                 alloc_.construct (di, *si);
     131                            for (pointer si2 = p_data; si2 != p_data + size_; ++si2) {
     132                                alloc_.construct (di, *si2);
    133133                                ++di;
    134134                            }
    135135                            for (; di != data_ + size; ++di) {

  • boost/numeric/ublas/triangular.hpp 

    diff -dur boost_1_53_0/boost/numeric/ublas/triangular.hpp Boost/boost/numeric/ublas/triangular.hpp
    old new  
    21622162                singular ().raise ();
    21632163#endif
    21642164            value_type t = e2 () (n);
    2165             for (difference_type m = n + 1; m < e1 ().size2(); ++ m) {
     2165            for (difference_type m = n + 1; m < static_cast<difference_type>(e1 ().size2()); ++ m) {
    21662166              t -= e1 () (n, m)  * e2 () (m);
    21672167            }
    21682168            e2() (n) = t / e1 () (n, n);

  • boost/numeric/ublas/vector.hpp 

    diff -dur boost_1_53_0/boost/numeric/ublas/vector.hpp Boost/boost/numeric/ublas/vector.hpp
    old new  
    8585        BOOST_UBLAS_INLINE
    8686        vector (size_type size, const array_type &data):
    8787            vector_container<self_type> (),
    88             data_ (data) {}
     88            data_ (data) {(void)size;}
    8989
    9090        /// \brief Constructor of a vector by copying from another container
    9191        /// This type has the generic name \c array_typ within the vector definition.
    … …  
    354354        /// \brief Assign the sum of the vector and a vector_expression to the vector
    355355        /// Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
    356356        /// No temporary is created. Computations are done and stored directly into the resulting vector.
    357         /// \tparam AE is the type of the vector_expression
    358         /// \param ae is a const reference to the vector_expression
    359357        /// \return a reference to the resulting vector
    360358        template<class C>          // Container assignment without temporary
    361359        BOOST_UBLAS_INLINE
    … …  
    392390        /// \brief Assign the difference of the vector and a vector_expression to the vector
    393391        /// Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
    394392        /// No temporary is created. Computations are done and stored directly into the resulting vector.
    395         /// \tparam AE is the type of the vector_expression
    396         /// \param ae is a const reference to the vector_expression
    397393        /// \return a reference to the resulting vector
    398394        template<class C>          // Container assignment without temporary
    399395        BOOST_UBLAS_INLINE
    … …  
    418414        /// \brief Assign the product of the vector and a scalar to the vector
    419415        /// Assign the product of the vector and a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
    420416        /// No temporary is created. Computations are done and stored directly into the resulting vector.
    421         /// \tparam AE is the type of the vector_expression
    422417        /// \param at is a const reference to the scalar
    423418        /// \return a reference to the resulting vector
    424419        template<class AT>
    … …  
    431426        /// \brief Assign the division of the vector by a scalar to the vector
    432427        /// Assign the division of the vector by a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression.
    433428        /// No temporary is created. Computations are done and stored directly into the resulting vector.
    434         /// \tparam AE is the type of the vector_expression
    435429        /// \param at is a const reference to the scalar
    436430        /// \return a reference to the resulting vector
    437431        template<class AT>
    … …  
    782776       
    783777        /// Serialize a vector into and archive as defined in Boost
    784778        /// \param ar Archive object. Can be a flat file, an XML file or any other stream
    785         /// \param file_version Optional file version (not yet used)
    786779        template<class Archive>
    787780        void serialize(Archive & ar, const unsigned int /* file_version */){
    788781            ar & serialization::make_nvp("data",data_);
    … …  
    923916        // Element support
    924917        BOOST_UBLAS_INLINE
    925918        const_pointer find_element (size_type i) const {
     919            (void)i;
    926920            return & zero_;
    927921        }
    928922
    … …  
    16321626        // Resizing
    16331627        BOOST_UBLAS_INLINE
    16341628        void resize (size_type size, bool preserve = true) {
     1629            (void)preserve;
    16351630            if (size > N)
    16361631                bad_size ().raise ();
    16371632            size_ = size;

  • boost/range/iterator_range_core.hpp 

    diff -dur boost_1_53_0/boost/range/iterator_range_core.hpp Boost/boost/range/iterator_range_core.hpp
    old new  
    631631            Construct a new sequence of the specified type from the elements
    632632            in the given range
    633633
    634             \param Range An input range
     634            \tparam Range An input range
    635635            \return New sequence
    636636        */
    637         template< typename SeqT, typename Range >
     637        template< typename SeqT, class Range >
    638638        inline SeqT copy_range( const Range& r )
    639639        {
    640640            return SeqT( boost::begin( r ), boost::end( r ) );

  • boost/serialization/collection_size_type.hpp 

    diff -dur boost_1_53_0/boost/serialization/collection_size_type.hpp Boost/boost/serialization/collection_size_type.hpp
    old new  
    2222    typedef std::size_t base_type;
    2323    base_type t;
    2424public:
    25     collection_size_type(): t(0) {};
     25    collection_size_type(): t(0) {}
    2626    explicit collection_size_type(const std::size_t & t_) :
    2727        t(t_)
    2828    {}

  • boost/serialization/strong_typedef.hpp 

    diff -dur boost_1_53_0/boost/serialization/strong_typedef.hpp Boost/boost/serialization/strong_typedef.hpp
    old new  
    3333        > >                                                         \
    3434    {                                                               \
    3535        T t;                                                        \
    36         explicit D(const T t_) : t(t_) {};                          \
    37         D(): t() {};                                                \
     36        explicit D(const T t_) : t(t_) {}                          \
     37        D(): t() {}                                                \
    3838        D(const D & t_) : t(t_.t){}                                 \
    3939        D & operator=(const D & rhs) { t = rhs.t; return *this;}    \
    4040        D & operator=(const T & rhs) { t = rhs; return *this;}      \
    … …  
    5151        > >                                                         \
    5252    {                                                               \
    5353        T t;                                                        \
    54         explicit D(const T t_) : t(t_) {};                          \
    55         D() : t(){};                                                \
     54        explicit D(const T t_) : t(t_) {}                          \
     55        D() : t(){}                                                \
    5656        D(const D & t_) : t(t_.t){}                                 \
    5757        D & operator=(const D & rhs) { t = rhs.t; return *this;}    \
    5858        D & operator=(const T & rhs) { t = rhs; return *this;}      \

  • boost/strong_typedef.hpp 

    diff -dur boost_1_53_0/boost/strong_typedef.hpp Boost/boost/strong_typedef.hpp
    old new  
    3333        > >                                                         \
    3434    {                                                               \
    3535        T t;                                                        \
    36         explicit D(const T t_) : t(t_) {};                          \
    37         D(){};                                                      \
     36        explicit D(const T t_) : t(t_) {}                          \
     37        D(){}                                                      \
    3838        D(const D & t_) : t(t_.t){}                                 \
    3939        D & operator=(const D & rhs) { t = rhs.t; return *this;}    \
    4040        D & operator=(const T & rhs) { t = rhs; return *this;}      \
    … …  
    5151        > >                                                         \
    5252    {                                                               \
    5353        T t;                                                        \
    54         explicit D(const T t_) : t(t_) {};                          \
    55         D(){};                                                      \
     54        explicit D(const T t_) : t(t_) {}                          \
     55        D(){}                                                      \
    5656        D(const D & t_) : t(t_.t){}                                 \
    5757        D & operator=(const D & rhs) { t = rhs.t; return *this;}    \
    5858        D & operator=(const T & rhs) { t = rhs; return *this;}      \