Subject: [Boost-commit] svn:boost r61435 - in trunk: boost/format boost/function boost/interprocess/detail boost/interprocess/sync/xsi boost/numeric/ublas boost/numeric/ublas/detail boost/numeric/ublas/experimental boost/python/detail boost/range boost/range/adaptor boost/range/algorithm boost/range/algorithm_ext boost/range/detail boost/spirit/home/karma/detail boost/test/impl boost/test/utils libs/format/test libs/intrusive/test libs/numeric/ublas/test libs/pool/test libs/program_options/example libs/python/test libs/range/test libs/range/test/adaptor_test libs/range/test/algorithm_test libs/range/test/test_driver libs/spirit/example/scheme/input libs/test/doc/src/examples tools/regression/test/test-boost-build/missing_dependencies tools/regression/test/test-boost-build/missing_dependencies/lib
From: jewillco_at_[hidden]
Date: 2010-04-20 13:54:22
Author: jewillco
Date: 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
New Revision: 61435
URL: http://svn.boost.org/trac/boost/changeset/61435
Log:
Fixed tab and no-newline-at-end-of-file issues from inspection report
Text files modified:
trunk/boost/format/format_implementation.hpp | 42 ++--
trunk/boost/function/function_base.hpp | 8
trunk/boost/interprocess/detail/move.hpp | 2
trunk/boost/interprocess/sync/xsi/xsi_named_mutex.hpp | 2
trunk/boost/numeric/ublas/detail/concepts.hpp | 10
trunk/boost/numeric/ublas/experimental/sparse_view.hpp | 202 ++++++++++++------------
trunk/boost/numeric/ublas/traits.hpp | 146 +++++++++---------
trunk/boost/python/detail/wrap_python.hpp | 4
trunk/boost/range/adaptor/adjacent_filtered.hpp | 312 +++++++++++++++++++-------------------
trunk/boost/range/adaptor/argument_fwd.hpp | 98 ++++++------
trunk/boost/range/adaptor/copied.hpp | 54 +++---
trunk/boost/range/adaptor/filtered.hpp | 138 ++++++++--------
trunk/boost/range/adaptor/indexed.hpp | 136 ++++++++--------
trunk/boost/range/adaptor/indirected.hpp | 108 ++++++------
trunk/boost/range/adaptor/map.hpp | 314 ++++++++++++++++++++--------------------
trunk/boost/range/adaptor/replaced.hpp | 182 +++++++++++-----------
trunk/boost/range/adaptor/replaced_if.hpp | 210 +++++++++++++-------------
trunk/boost/range/adaptor/reversed.hpp | 130 ++++++++--------
trunk/boost/range/adaptor/sliced.hpp | 30 +-
trunk/boost/range/adaptor/strided.hpp | 242 +++++++++++++++---------------
trunk/boost/range/adaptor/tokenized.hpp | 224 ++++++++++++++--------------
trunk/boost/range/adaptor/transformed.hpp | 158 ++++++++++----------
trunk/boost/range/adaptor/uniqued.hpp | 134 ++++++++--------
trunk/boost/range/algorithm/equal.hpp | 2
trunk/boost/range/algorithm/remove_copy_if.hpp | 2
trunk/boost/range/algorithm_ext/for_each.hpp | 80 +++++-----
trunk/boost/range/counting_range.hpp | 58 +++---
trunk/boost/range/detail/demote_iterator_traversal_tag.hpp | 8
trunk/boost/range/join.hpp | 48 +++---
trunk/boost/range/numeric.hpp | 116 +++++++-------
trunk/boost/range/size_type.hpp | 2
trunk/boost/spirit/home/karma/detail/alternative_function.hpp | 2
trunk/boost/test/impl/unit_test_parameters.ipp | 4
trunk/boost/test/utils/setcolor.hpp | 2
trunk/libs/format/test/format_test3.cpp | 36 ++--
trunk/libs/intrusive/test/generic_assoc_test.hpp | 4
trunk/libs/numeric/ublas/test/sparse_view_test.cpp | 12
trunk/libs/numeric/ublas/test/utils.hpp | 4
trunk/libs/pool/test/sys_allocator.hpp | 2
trunk/libs/program_options/example/multiple_sources.cpp | 2
trunk/libs/python/test/exec.cpp | 6
trunk/libs/range/test/adaptor_test/adjacent_filtered_example.cpp | 2
trunk/libs/range/test/adaptor_test/copied_example.cpp | 2
trunk/libs/range/test/algorithm_test/find.cpp | 20 +-
trunk/libs/range/test/algorithm_test/find_end.cpp | 38 ++--
trunk/libs/range/test/algorithm_test/find_first_of.cpp | 38 ++--
trunk/libs/range/test/algorithm_test/find_if.cpp | 20 +-
trunk/libs/range/test/algorithm_test/for_each.cpp | 2
trunk/libs/range/test/algorithm_test/lower_bound.cpp | 44 ++--
trunk/libs/range/test/algorithm_test/max_element.cpp | 34 ++--
trunk/libs/range/test/algorithm_test/min_element.cpp | 34 ++--
trunk/libs/range/test/algorithm_test/partition.cpp | 18 +-
trunk/libs/range/test/algorithm_test/stable_partition.cpp | 18 +-
trunk/libs/range/test/algorithm_test/unique.cpp | 34 ++--
trunk/libs/range/test/algorithm_test/upper_bound.cpp | 48 +++---
trunk/libs/range/test/counting_range.cpp | 2
trunk/libs/range/test/iterator_range.cpp | 2
trunk/libs/range/test/test_driver/range_return_test_driver.hpp | 30 +-
trunk/libs/spirit/example/scheme/input/sexpr.hpp | 2
trunk/libs/test/doc/src/examples/example17.cpp | 2
trunk/libs/test/doc/src/examples/example22.cpp | 2
trunk/libs/test/doc/src/examples/example23.cpp | 2
trunk/tools/regression/test/test-boost-build/missing_dependencies/lib/lib.cpp | 2
trunk/tools/regression/test/test-boost-build/missing_dependencies/test.cpp | 2
64 files changed, 1837 insertions(+), 1837 deletions(-)
Modified: trunk/boost/format/format_implementation.hpp
==============================================================================
--- trunk/boost/format/format_implementation.hpp (original)
+++ trunk/boost/format/format_implementation.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -174,25 +174,25 @@
template< class Ch, class Tr, class Alloc>
int basic_format<Ch,Tr, Alloc>::
bound_args() const {
- if(bound_.size()==0)
- return 0;
- int n=0;
- for(int i=0; i<num_args_ ; ++i)
- if(bound_[i])
- ++n;
- return n;
+ if(bound_.size()==0)
+ return 0;
+ int n=0;
+ for(int i=0; i<num_args_ ; ++i)
+ if(bound_[i])
+ ++n;
+ return n;
}
template< class Ch, class Tr, class Alloc>
int basic_format<Ch,Tr, Alloc>::
fed_args() const {
- if(bound_.size()==0)
- return cur_arg_;
- int n=0;
- for(int i=0; i<cur_arg_ ; ++i)
- if(!bound_[i])
- ++n;
- return n;
+ if(bound_.size()==0)
+ return cur_arg_;
+ int n=0;
+ for(int i=0; i<cur_arg_ ; ++i)
+ if(!bound_[i])
+ ++n;
+ return n;
}
template< class Ch, class Tr, class Alloc>
@@ -203,13 +203,13 @@
template< class Ch, class Tr, class Alloc>
int basic_format<Ch,Tr, Alloc>::
remaining_args() const {
- if(bound_.size()==0)
- return num_args_-cur_arg_;
- int n=0;
- for(int i=cur_arg_; i<num_args_ ; ++i)
- if(!bound_[i])
- ++n;
- return n;
+ if(bound_.size()==0)
+ return num_args_-cur_arg_;
+ int n=0;
+ for(int i=cur_arg_; i<num_args_ ; ++i)
+ if(!bound_[i])
+ ++n;
+ return n;
}
template< class Ch, class Tr, class Alloc>
Modified: trunk/boost/function/function_base.hpp
==============================================================================
--- trunk/boost/function/function_base.hpp (original)
+++ trunk/boost/function/function_base.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -264,12 +264,12 @@
A(a)
{
}
-
- functor_wrapper(const functor_wrapper& f) :
+
+ functor_wrapper(const functor_wrapper& f) :
F(static_cast<const F&>(f)),
A(static_cast<const A&>(f))
- {
- }
+ {
+ }
};
/**
Modified: trunk/boost/interprocess/detail/move.hpp
==============================================================================
--- trunk/boost/interprocess/detail/move.hpp (original)
+++ trunk/boost/interprocess/detail/move.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -968,4 +968,4 @@
INTERPROCESS_NAMESPACE_END
} //namespace boost {
-#endif //#ifndef BOOST_MOVE_HPP
+#endif //#ifndef BOOST_MOVE_HPP
Modified: trunk/boost/interprocess/sync/xsi/xsi_named_mutex.hpp
==============================================================================
--- trunk/boost/interprocess/sync/xsi/xsi_named_mutex.hpp (original)
+++ trunk/boost/interprocess/sync/xsi/xsi_named_mutex.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -188,7 +188,7 @@
inline void xsi_named_mutex::lock()
{
- if(!xsi::simple_sem_op(m_semid, -1)){
+ if(!xsi::simple_sem_op(m_semid, -1)){
error_info err = system_error_code();
throw interprocess_exception(err);
}
Modified: trunk/boost/numeric/ublas/detail/concepts.hpp
==============================================================================
--- trunk/boost/numeric/ublas/detail/concepts.hpp (original)
+++ trunk/boost/numeric/ublas/detail/concepts.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -499,7 +499,7 @@
void constraints () {
function_requires< VectorConcept<vector_type> >();
- function_requires< DefaultConstructible<vector_type> >();
+ function_requires< DefaultConstructible<vector_type> >();
function_requires< Mutable_VectorExpressionConcept<vector_type> >();
size_type n (0);
value_type t = value_type ();
@@ -580,7 +580,7 @@
void constraints () {
function_requires< MatrixConcept<matrix_type> >();
- function_requires< DefaultConstructible<matrix_type> >();
+ function_requires< DefaultConstructible<matrix_type> >();
function_requires< Mutable_MatrixExpressionConcept<matrix_type> >();
size_type n (0);
value_type t = value_type ();
@@ -905,8 +905,8 @@
#define INTERNAL_EXPRESSION
#endif
- // TODO enable this for development
- // #define VIEW_CONCEPTS
+ // TODO enable this for development
+ // #define VIEW_CONCEPTS
// Element value type for tests
typedef float T;
@@ -980,7 +980,7 @@
#endif
#ifdef VIEW_CONCEPTS
- // read only vectors
+ // read only vectors
{
typedef vector_view<T> container_model;
function_requires< RandomAccessContainerConcept<container_model> >();
Modified: trunk/boost/numeric/ublas/experimental/sparse_view.hpp
==============================================================================
--- trunk/boost/numeric/ublas/experimental/sparse_view.hpp (original)
+++ trunk/boost/numeric/ublas/experimental/sparse_view.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -26,42 +26,42 @@
template < class T >
class c_array_view
- : public storage_array< c_array_view<T> > {
+ : public storage_array< c_array_view<T> > {
private:
- typedef c_array_view<T> self_type;
- typedef T * pointer;
+ typedef c_array_view<T> self_type;
+ typedef T * pointer;
public:
- // TODO: think about a const pointer
- typedef const pointer array_type;
+ // TODO: think about a const pointer
+ typedef const pointer array_type;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
- typedef T value_type;
- typedef const T &const_reference;
- typedef const T *const_pointer;
+ typedef T value_type;
+ typedef const T &const_reference;
+ typedef const T *const_pointer;
typedef const_pointer const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
- //
- // typedefs required by vector concept
- //
+ //
+ // typedefs required by vector concept
+ //
- typedef dense_tag storage_category;
+ typedef dense_tag storage_category;
typedef const vector_reference<const self_type> const_closure_type;
- c_array_view(size_type size, array_type data) :
- size_(size), data_(data)
- {}
-
- ~c_array_view()
- {}
-
- //
- // immutable methods of container concept
- //
+ c_array_view(size_type size, array_type data) :
+ size_(size), data_(data)
+ {}
+
+ ~c_array_view()
+ {}
+
+ //
+ // immutable methods of container concept
+ //
BOOST_UBLAS_INLINE
size_type size () const {
@@ -93,8 +93,8 @@
}
private:
- size_type size_;
- array_type data_;
+ size_type size_;
+ array_type data_;
};
@@ -133,14 +133,14 @@
// ISSUE require type consistency check
// is_convertable (IA::size_type, TA::size_type)
typedef typename boost::remove_cv<typename vector_view_traits<JA>::value_type>::type index_type;
- // for compatibility, should be removed some day ...
+ // for compatibility, should be removed some day ...
typedef index_type size_type;
// size_type for the data arrays.
typedef typename vector_view_traits<JA>::size_type array_size_type;
typedef typename vector_view_traits<JA>::difference_type difference_type;
typedef const value_type & const_reference;
- // do NOT define reference type, because class is read only
+ // do NOT define reference type, because class is read only
// typedef value_type & reference;
typedef IA rowptr_array_type;
@@ -149,93 +149,93 @@
typedef const matrix_reference<const self_type> const_closure_type;
typedef matrix_reference<self_type> closure_type;
- // FIXME: define a corresponding temporary type
+ // FIXME: define a corresponding temporary type
// typedef compressed_vector<T, IB, IA, TA> vector_temporary_type;
- // FIXME: define a corresponding temporary type
+ // FIXME: define a corresponding temporary type
// typedef self_type matrix_temporary_type;
typedef sparse_tag storage_category;
typedef typename L::orientation_category orientation_category;
- //
- // private types for internal use
- //
+ //
+ // private types for internal use
+ //
private:
- typedef typename vector_view_traits<index_array_type>::const_iterator const_subiterator_type;
+ typedef typename vector_view_traits<index_array_type>::const_iterator const_subiterator_type;
- //
+ //
// Construction and destruction
- //
+ //
private:
- /// private default constructor because data must be filled by caller
+ /// private default constructor because data must be filled by caller
BOOST_UBLAS_INLINE
compressed_matrix_view () { }
public:
- BOOST_UBLAS_INLINE
+ BOOST_UBLAS_INLINE
compressed_matrix_view (index_type n_rows, index_type n_cols, array_size_type nnz
- , const rowptr_array_type & iptr
- , const index_array_type & jptr
- , const value_array_type & values):
+ , const rowptr_array_type & iptr
+ , const index_array_type & jptr
+ , const value_array_type & values):
matrix_expression<self_type> (),
size1_ (n_rows), size2_ (n_cols),
nnz_ (nnz),
index1_data_ (iptr),
- index2_data_ (jptr),
- value_data_ (values) {
+ index2_data_ (jptr),
+ value_data_ (values) {
storage_invariants ();
}
- BOOST_UBLAS_INLINE
- compressed_matrix_view(const compressed_matrix_view& o) :
- size1_(size1_), size2_(size2_),
- nnz_(nnz_),
- index1_data_(index1_data_),
- index2_data_(index2_data_),
- value_data_(value_data_)
- {}
-
- //
- // implement immutable iterator types
- //
+ BOOST_UBLAS_INLINE
+ compressed_matrix_view(const compressed_matrix_view& o) :
+ size1_(size1_), size2_(size2_),
+ nnz_(nnz_),
+ index1_data_(index1_data_),
+ index2_data_(index2_data_),
+ value_data_(value_data_)
+ {}
+
+ //
+ // implement immutable iterator types
+ //
- class const_iterator1 {};
- class const_iterator2 {};
+ class const_iterator1 {};
+ class const_iterator2 {};
- typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
+ typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
- //
- // implement all read only methods for the matrix expression concept
- //
-
- //! return the number of rows
- index_type size1() const {
- return size1_;
- }
-
- //! return the number of columns
- index_type size2() const {
- return size2_;
- }
-
- //! return value at position (i,j)
- value_type operator()(index_type i, index_type j) const {
- const_pointer p = find_element(i,j);
- if (!p) {
- return zero_;
- } else {
- return *p;
- }
- }
-
+ //
+ // implement all read only methods for the matrix expression concept
+ //
+
+ //! return the number of rows
+ index_type size1() const {
+ return size1_;
+ }
+
+ //! return the number of columns
+ index_type size2() const {
+ return size2_;
+ }
+
+ //! return value at position (i,j)
+ value_type operator()(index_type i, index_type j) const {
+ const_pointer p = find_element(i,j);
+ if (!p) {
+ return zero_;
+ } else {
+ return *p;
+ }
+ }
+
private:
- //
- // private helper functions
- //
+ //
+ // private helper functions
+ //
const_pointer find_element (index_type i, index_type j) const {
index_type element1 (layout_type::index_M (i, j));
@@ -244,22 +244,22 @@
const array_size_type itv = zero_based( index1_data_[element1] );
const array_size_type itv_next = zero_based( index1_data_[element1+1] );
- const_subiterator_type it_start = boost::next(vector_view_traits<index_array_type>::begin(index2_data_),itv);
- const_subiterator_type it_end = boost::next(vector_view_traits<index_array_type>::begin(index2_data_),itv_next);
+ const_subiterator_type it_start = boost::next(vector_view_traits<index_array_type>::begin(index2_data_),itv);
+ const_subiterator_type it_end = boost::next(vector_view_traits<index_array_type>::begin(index2_data_),itv_next);
const_subiterator_type it = find_index_in_row(it_start, it_end, element2) ;
-
+
if (it == it_end || *it != k_based (element2))
return 0;
return &value_data_ [it - vector_view_traits<index_array_type>::begin(index2_data_)];
}
- const_subiterator_type find_index_in_row(const_subiterator_type it_start
- , const_subiterator_type it_end
- , index_type index) const {
- return std::lower_bound( it_start
- , it_end
- , k_based (index) );
- }
+ const_subiterator_type find_index_in_row(const_subiterator_type it_start
+ , const_subiterator_type it_end
+ , index_type index) const {
+ return std::lower_bound( it_start
+ , it_end
+ , k_based (index) );
+ }
private:
@@ -301,13 +301,13 @@
template<class L, std::size_t IB, class IA, class JA, class TA >
compressed_matrix_view<L,IB,IA,JA,TA>
make_compressed_matrix_view(typename vector_view_traits<JA>::value_type n_rows
- , typename vector_view_traits<JA>::value_type n_cols
- , typename vector_view_traits<JA>::size_type nnz
- , const IA & ia
- , const JA & ja
- , const TA & ta) {
+ , typename vector_view_traits<JA>::value_type n_cols
+ , typename vector_view_traits<JA>::size_type nnz
+ , const IA & ia
+ , const JA & ja
+ , const TA & ta) {
- return compressed_matrix_view<L,IB,IA,JA,TA>(n_rows, n_cols, nnz, ia, ja, ta);
+ return compressed_matrix_view<L,IB,IA,JA,TA>(n_rows, n_cols, nnz, ia, ja, ta);
}
Modified: trunk/boost/numeric/ublas/traits.hpp
==============================================================================
--- trunk/boost/numeric/ublas/traits.hpp (original)
+++ trunk/boost/numeric/ublas/traits.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -67,82 +67,82 @@
template<typename R, typename I>
typename boost::enable_if<
- mpl::and_<
- boost::is_float<R>,
- boost::is_integral<I>
- >,
- std::complex<R> >::type inline operator+ (I in1, std::complex<R> const& in2 ) {
- return R (in1) + in2;
+ mpl::and_<
+ boost::is_float<R>,
+ boost::is_integral<I>
+ >,
+ std::complex<R> >::type inline operator+ (I in1, std::complex<R> const& in2 ) {
+ return R (in1) + in2;
}
template<typename R, typename I>
typename boost::enable_if<
- mpl::and_<
- boost::is_float<R>,
- boost::is_integral<I>
- >,
- std::complex<R> >::type inline operator+ (std::complex<R> const& in1, I in2) {
- return in1 + R (in2);
+ mpl::and_<
+ boost::is_float<R>,
+ boost::is_integral<I>
+ >,
+ std::complex<R> >::type inline operator+ (std::complex<R> const& in1, I in2) {
+ return in1 + R (in2);
}
template<typename R, typename I>
typename boost::enable_if<
- mpl::and_<
- boost::is_float<R>,
- boost::is_integral<I>
- >,
- std::complex<R> >::type inline operator- (I in1, std::complex<R> const& in2) {
- return R (in1) - in2;
+ mpl::and_<
+ boost::is_float<R>,
+ boost::is_integral<I>
+ >,
+ std::complex<R> >::type inline operator- (I in1, std::complex<R> const& in2) {
+ return R (in1) - in2;
}
template<typename R, typename I>
typename boost::enable_if<
- mpl::and_<
- boost::is_float<R>,
- boost::is_integral<I>
- >,
- std::complex<R> >::type inline operator- (std::complex<R> const& in1, I in2) {
- return in1 - R (in2);
+ mpl::and_<
+ boost::is_float<R>,
+ boost::is_integral<I>
+ >,
+ std::complex<R> >::type inline operator- (std::complex<R> const& in1, I in2) {
+ return in1 - R (in2);
}
template<typename R, typename I>
typename boost::enable_if<
- mpl::and_<
- boost::is_float<R>,
- boost::is_integral<I>
- >,
- std::complex<R> >::type inline operator* (I in1, std::complex<R> const& in2) {
- return R (in1) * in2;
+ mpl::and_<
+ boost::is_float<R>,
+ boost::is_integral<I>
+ >,
+ std::complex<R> >::type inline operator* (I in1, std::complex<R> const& in2) {
+ return R (in1) * in2;
}
template<typename R, typename I>
typename boost::enable_if<
- mpl::and_<
- boost::is_float<R>,
- boost::is_integral<I>
- >,
- std::complex<R> >::type inline operator* (std::complex<R> const& in1, I in2) {
- return in1 * R(in2);
+ mpl::and_<
+ boost::is_float<R>,
+ boost::is_integral<I>
+ >,
+ std::complex<R> >::type inline operator* (std::complex<R> const& in1, I in2) {
+ return in1 * R(in2);
}
template<typename R, typename I>
typename boost::enable_if<
- mpl::and_<
- boost::is_float<R>,
- boost::is_integral<I>
- >,
- std::complex<R> >::type inline operator/ (I in1, std::complex<R> const& in2) {
- return R(in1) / in2;
+ mpl::and_<
+ boost::is_float<R>,
+ boost::is_integral<I>
+ >,
+ std::complex<R> >::type inline operator/ (I in1, std::complex<R> const& in2) {
+ return R(in1) / in2;
}
template<typename R, typename I>
typename boost::enable_if<
- mpl::and_<
- boost::is_float<R>,
- boost::is_integral<I>
- >,
- std::complex<R> >::type inline operator/ (std::complex<R> const& in1, I in2) {
- return in1 / R (in2);
+ mpl::and_<
+ boost::is_float<R>,
+ boost::is_integral<I>
+ >,
+ std::complex<R> >::type inline operator/ (std::complex<R> const& in1, I in2) {
+ return in1 / R (in2);
}
@@ -641,7 +641,7 @@
*/
template < class E >
struct container_traits
- : container_view_traits<E>, mutable_container_traits<E> {
+ : container_view_traits<E>, mutable_container_traits<E> {
};
@@ -667,7 +667,7 @@
*/
template < class MATRIX >
struct mutable_matrix_traits
- : mutable_container_traits <MATRIX> {
+ : mutable_container_traits <MATRIX> {
/// row iterator for the matrix
typedef typename MATRIX::iterator1 iterator1;
@@ -682,7 +682,7 @@
*/
template < class MATRIX >
struct matrix_traits
- : matrix_view_traits <MATRIX>, mutable_matrix_traits <MATRIX> {
+ : matrix_view_traits <MATRIX>, mutable_matrix_traits <MATRIX> {
};
/** \brief Traits class to extract type information from a VECTOR.
@@ -694,16 +694,16 @@
/// iterator for the VECTOR
typedef typename VECTOR::const_iterator const_iterator;
- /// iterator pointing to the first element
- static
- const_iterator begin(const VECTOR & v) {
- return v.begin();
- }
- /// iterator pointing behind the last element
- static
- const_iterator end(const VECTOR & v) {
- return v.end();
- }
+ /// iterator pointing to the first element
+ static
+ const_iterator begin(const VECTOR & v) {
+ return v.begin();
+ }
+ /// iterator pointing behind the last element
+ static
+ const_iterator end(const VECTOR & v) {
+ return v.end();
+ }
};
@@ -715,17 +715,17 @@
/// iterator for the VECTOR
typedef typename VECTOR::iterator iterator;
- /// iterator pointing to the first element
- static
- iterator begin(VECTOR & v) {
- return v.begin();
- }
-
- /// iterator pointing behind the last element
- static
- iterator end(VECTOR & v) {
- return v.end();
- }
+ /// iterator pointing to the first element
+ static
+ iterator begin(VECTOR & v) {
+ return v.begin();
+ }
+
+ /// iterator pointing behind the last element
+ static
+ iterator end(VECTOR & v) {
+ return v.end();
+ }
};
/** \brief Traits class to extract type information from a VECTOR.
@@ -733,7 +733,7 @@
*/
template < class VECTOR >
struct vector_traits
- : vector_view_traits <VECTOR>, mutable_vector_traits <VECTOR> {
+ : vector_view_traits <VECTOR>, mutable_vector_traits <VECTOR> {
};
Modified: trunk/boost/python/detail/wrap_python.hpp
==============================================================================
--- trunk/boost/python/detail/wrap_python.hpp (original)
+++ trunk/boost/python/detail/wrap_python.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -182,8 +182,8 @@
# define Py_REFCNT(o) (((PyObject*)(o))->ob_refcnt)
# define Py_SIZE(o) (((PyVarObject*)(o))->ob_size)
-# define PyVarObject_HEAD_INIT(type, size) \
- PyObject_HEAD_INIT(type) size,
+# define PyVarObject_HEAD_INIT(type, size) \
+ PyObject_HEAD_INIT(type) size,
#endif
Modified: trunk/boost/range/adaptor/adjacent_filtered.hpp
==============================================================================
--- trunk/boost/range/adaptor/adjacent_filtered.hpp (original)
+++ trunk/boost/range/adaptor/adjacent_filtered.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -28,11 +28,11 @@
namespace boost
{
- namespace range_detail
- {
- template< class Iter, class Pred, bool default_pass >
- class skip_iterator
- : public boost::iterator_adaptor<
+ namespace range_detail
+ {
+ template< class Iter, class Pred, bool default_pass >
+ class skip_iterator
+ : public boost::iterator_adaptor<
skip_iterator<Iter,Pred,default_pass>,
Iter,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::value_type,
@@ -40,10 +40,10 @@
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::reference,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::difference_type
>
- , private Pred
- {
- private:
- typedef boost::iterator_adaptor<
+ , private Pred
+ {
+ private:
+ typedef boost::iterator_adaptor<
skip_iterator<Iter,Pred,default_pass>,
Iter,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::value_type,
@@ -52,9 +52,9 @@
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::difference_type
> base_t;
- public:
+ public:
typedef Pred pred_t;
- typedef Iter iter_t;
+ typedef Iter iter_t;
skip_iterator() : m_last() {}
@@ -66,169 +66,169 @@
move_to_next_valid();
}
- template<class OtherIter>
- skip_iterator( const skip_iterator<OtherIter, pred_t, default_pass>& other )
- : base_t(other.base())
- , pred_t(other)
- , m_last(other.m_last) {}
+ template<class OtherIter>
+ skip_iterator( const skip_iterator<OtherIter, pred_t, default_pass>& other )
+ : base_t(other.base())
+ , pred_t(other)
+ , m_last(other.m_last) {}
void move_to_next_valid()
- {
- iter_t& it = this->base_reference();
- pred_t& bi_pred = *this;
- if (it != m_last)
- {
- if (default_pass)
- {
- iter_t nxt = ::boost::next(it);
- while (nxt != m_last && !bi_pred(*it, *nxt))
- {
- ++it;
- ++nxt;
- }
- }
- else
- {
- iter_t nxt = ::boost::next(it);
- for(; nxt != m_last; ++it, ++nxt)
- {
- if (bi_pred(*it, *nxt))
- {
- break;
- }
- }
- if (nxt == m_last)
- {
- it = m_last;
- }
- }
- }
- }
-
- void increment()
- {
- iter_t& it = this->base_reference();
- BOOST_ASSERT( it != m_last );
- ++it;
- move_to_next_valid();
- }
+ {
+ iter_t& it = this->base_reference();
+ pred_t& bi_pred = *this;
+ if (it != m_last)
+ {
+ if (default_pass)
+ {
+ iter_t nxt = ::boost::next(it);
+ while (nxt != m_last && !bi_pred(*it, *nxt))
+ {
+ ++it;
+ ++nxt;
+ }
+ }
+ else
+ {
+ iter_t nxt = ::boost::next(it);
+ for(; nxt != m_last; ++it, ++nxt)
+ {
+ if (bi_pred(*it, *nxt))
+ {
+ break;
+ }
+ }
+ if (nxt == m_last)
+ {
+ it = m_last;
+ }
+ }
+ }
+ }
+
+ void increment()
+ {
+ iter_t& it = this->base_reference();
+ BOOST_ASSERT( it != m_last );
+ ++it;
+ move_to_next_valid();
+ }
iter_t m_last;
- };
+ };
- template< class P, class R, bool default_pass >
- struct adjacent_filter_range
- : iterator_range< skip_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
- P,
- default_pass
+ template< class P, class R, bool default_pass >
+ struct adjacent_filter_range
+ : iterator_range< skip_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
+ P,
+ default_pass
>
>
- {
- private:
- typedef skip_iterator<
+ {
+ private:
+ typedef skip_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
P,
default_pass
>
- skip_iter;
+ skip_iter;
+
+ typedef iterator_range<skip_iter>
+ base_range;
- typedef iterator_range<skip_iter>
- base_range;
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<R>::type raw_iterator;
- typedef BOOST_DEDUCED_TYPENAME range_iterator<R>::type raw_iterator;
+ public:
+ adjacent_filter_range( const P& p, R& r )
+ : base_range( skip_iter( boost::begin(r), boost::end(r), p),
+ skip_iter( boost::end(r), boost::end(r), p) )
+ {
+ }
+ };
- public:
- adjacent_filter_range( const P& p, R& r )
- : base_range( skip_iter( boost::begin(r), boost::end(r), p),
- skip_iter( boost::end(r), boost::end(r), p) )
- {
- }
- };
-
- template< class T >
- struct adjacent_holder : holder<T>
- {
- adjacent_holder( T r ) : holder<T>(r)
- { }
- };
-
- template< class T >
- struct adjacent_excl_holder : holder<T>
- {
- adjacent_excl_holder( T r ) : holder<T>(r)
- { }
- };
-
- template< class ForwardRng, class BinPredicate >
- inline adjacent_filter_range<BinPredicate, ForwardRng, true>
- operator|( ForwardRng& r,
- const adjacent_holder<BinPredicate>& f )
- {
- return adjacent_filter_range<BinPredicate, ForwardRng, true>( f.val, r );
- }
-
- template< class ForwardRng, class BinPredicate >
- inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
- operator|( const ForwardRng& r,
- const adjacent_holder<BinPredicate>& f )
- {
- return adjacent_filter_range<BinPredicate,
- const ForwardRng, true>( f.val, r );
- }
-
- template< class ForwardRng, class BinPredicate >
- inline adjacent_filter_range<BinPredicate, ForwardRng, false>
- operator|( ForwardRng& r,
- const adjacent_excl_holder<BinPredicate>& f )
- {
- return adjacent_filter_range<BinPredicate, ForwardRng, false>( f.val, r );
- }
-
- template< class ForwardRng, class BinPredicate >
- inline adjacent_filter_range<BinPredicate, ForwardRng, false>
- operator|( const ForwardRng& r,
- const adjacent_excl_holder<BinPredicate>& f )
- {
- return adjacent_filter_range<BinPredicate,
- const ForwardRng, false>( f.val, r );
- }
-
- } // 'range_detail'
-
- // Bring adjacent_filter_range into the boost namespace so that users of
- // this library may specify the return type of the '|' operator and
- // adjacent_filter()
- using range_detail::adjacent_filter_range;
-
- namespace adaptors
- {
- namespace
- {
- const range_detail::forwarder<range_detail::adjacent_holder>
+ template< class T >
+ struct adjacent_holder : holder<T>
+ {
+ adjacent_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ template< class T >
+ struct adjacent_excl_holder : holder<T>
+ {
+ adjacent_excl_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ template< class ForwardRng, class BinPredicate >
+ inline adjacent_filter_range<BinPredicate, ForwardRng, true>
+ operator|( ForwardRng& r,
+ const adjacent_holder<BinPredicate>& f )
+ {
+ return adjacent_filter_range<BinPredicate, ForwardRng, true>( f.val, r );
+ }
+
+ template< class ForwardRng, class BinPredicate >
+ inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
+ operator|( const ForwardRng& r,
+ const adjacent_holder<BinPredicate>& f )
+ {
+ return adjacent_filter_range<BinPredicate,
+ const ForwardRng, true>( f.val, r );
+ }
+
+ template< class ForwardRng, class BinPredicate >
+ inline adjacent_filter_range<BinPredicate, ForwardRng, false>
+ operator|( ForwardRng& r,
+ const adjacent_excl_holder<BinPredicate>& f )
+ {
+ return adjacent_filter_range<BinPredicate, ForwardRng, false>( f.val, r );
+ }
+
+ template< class ForwardRng, class BinPredicate >
+ inline adjacent_filter_range<BinPredicate, ForwardRng, false>
+ operator|( const ForwardRng& r,
+ const adjacent_excl_holder<BinPredicate>& f )
+ {
+ return adjacent_filter_range<BinPredicate,
+ const ForwardRng, false>( f.val, r );
+ }
+
+ } // 'range_detail'
+
+ // Bring adjacent_filter_range into the boost namespace so that users of
+ // this library may specify the return type of the '|' operator and
+ // adjacent_filter()
+ using range_detail::adjacent_filter_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder<range_detail::adjacent_holder>
adjacent_filtered =
range_detail::forwarder<range_detail::adjacent_holder>();
- const range_detail::forwarder<range_detail::adjacent_excl_holder>
- adjacent_filtered_excl =
- range_detail::forwarder<range_detail::adjacent_excl_holder>();
- }
-
- template<class ForwardRng, class BinPredicate>
- inline adjacent_filter_range<BinPredicate, ForwardRng, true>
- adjacent_filter(ForwardRng& rng, BinPredicate filter_pred)
- {
- return adjacent_filter_range<BinPredicate, ForwardRng, true>(filter_pred, rng);
- }
-
- template<class ForwardRng, class BinPredicate>
- inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
- adjacent_filter(const ForwardRng& rng, BinPredicate filter_pred)
- {
- return adjacent_filter_range<BinPredicate, const ForwardRng, true>(filter_pred, rng);
- }
+ const range_detail::forwarder<range_detail::adjacent_excl_holder>
+ adjacent_filtered_excl =
+ range_detail::forwarder<range_detail::adjacent_excl_holder>();
+ }
+
+ template<class ForwardRng, class BinPredicate>
+ inline adjacent_filter_range<BinPredicate, ForwardRng, true>
+ adjacent_filter(ForwardRng& rng, BinPredicate filter_pred)
+ {
+ return adjacent_filter_range<BinPredicate, ForwardRng, true>(filter_pred, rng);
+ }
+
+ template<class ForwardRng, class BinPredicate>
+ inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
+ adjacent_filter(const ForwardRng& rng, BinPredicate filter_pred)
+ {
+ return adjacent_filter_range<BinPredicate, const ForwardRng, true>(filter_pred, rng);
+ }
- } // 'adaptors'
+ } // 'adaptors'
}
Modified: trunk/boost/range/adaptor/argument_fwd.hpp
==============================================================================
--- trunk/boost/range/adaptor/argument_fwd.hpp (original)
+++ trunk/boost/range/adaptor/argument_fwd.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -20,57 +20,57 @@
namespace boost
{
- namespace range_detail
- {
- template< class T >
- struct holder
- {
- T val;
- holder( T t ) : val(t)
- { }
- };
-
- template< class T >
- struct holder2
- {
- T val1, val2;
- holder2( T t, T u ) : val1(t), val2(u)
- { }
- };
-
- template< template<class> class Holder >
- struct forwarder
- {
- template< class T >
- Holder<T> operator()( T t ) const
- {
- return Holder<T>(t);
- }
- };
-
- template< template<class> class Holder >
- struct forwarder2
- {
- template< class T >
- Holder<T> operator()( T t, T u ) const
- {
- return Holder<T>(t,u);
- }
- };
-
- template< template<class,class> class Holder >
- struct forwarder2TU
- {
- template< class T, class U >
- Holder<T, U> operator()( T t, U u ) const
- {
- return Holder<T, U>(t, u);
- }
- };
+ namespace range_detail
+ {
+ template< class T >
+ struct holder
+ {
+ T val;
+ holder( T t ) : val(t)
+ { }
+ };
+
+ template< class T >
+ struct holder2
+ {
+ T val1, val2;
+ holder2( T t, T u ) : val1(t), val2(u)
+ { }
+ };
+
+ template< template<class> class Holder >
+ struct forwarder
+ {
+ template< class T >
+ Holder<T> operator()( T t ) const
+ {
+ return Holder<T>(t);
+ }
+ };
+
+ template< template<class> class Holder >
+ struct forwarder2
+ {
+ template< class T >
+ Holder<T> operator()( T t, T u ) const
+ {
+ return Holder<T>(t,u);
+ }
+ };
+
+ template< template<class,class> class Holder >
+ struct forwarder2TU
+ {
+ template< class T, class U >
+ Holder<T, U> operator()( T t, U u ) const
+ {
+ return Holder<T, U>(t, u);
+ }
+ };
- }
-
+ }
+
}
#ifdef BOOST_MSVC
Modified: trunk/boost/range/adaptor/copied.hpp
==============================================================================
--- trunk/boost/range/adaptor/copied.hpp (original)
+++ trunk/boost/range/adaptor/copied.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -18,40 +18,40 @@
namespace boost
{
- namespace adaptors
- {
- struct copied
- {
- copied(std::size_t t_, std::size_t u_)
+ namespace adaptors
+ {
+ struct copied
+ {
+ copied(std::size_t t_, std::size_t u_)
: t(t_), u(u_) {}
std::size_t t;
std::size_t u;
- };
+ };
- template< class CopyableRandomAccessRng >
- inline CopyableRandomAccessRng
- operator|( const CopyableRandomAccessRng& r, const copied& f )
- {
- iterator_range<
- BOOST_DEDUCED_TYPENAME range_iterator<const
- CopyableRandomAccessRng>::type >
- temp( adaptors::slice( r, f.t, f.u ) );
- return CopyableRandomAccessRng( temp.begin(), temp.end() );
- }
-
- template<class CopyableRandomAccessRange>
- inline CopyableRandomAccessRange
- copy(const CopyableRandomAccessRange& rng, std::size_t t, std::size_t u)
- {
- iterator_range<
- BOOST_DEDUCED_TYPENAME range_iterator<const
- CopyableRandomAccessRange>::type> temp(
- adaptors::slice(rng, t, u));
+ template< class CopyableRandomAccessRng >
+ inline CopyableRandomAccessRng
+ operator|( const CopyableRandomAccessRng& r, const copied& f )
+ {
+ iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<const
+ CopyableRandomAccessRng>::type >
+ temp( adaptors::slice( r, f.t, f.u ) );
+ return CopyableRandomAccessRng( temp.begin(), temp.end() );
+ }
+
+ template<class CopyableRandomAccessRange>
+ inline CopyableRandomAccessRange
+ copy(const CopyableRandomAccessRange& rng, std::size_t t, std::size_t u)
+ {
+ iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<const
+ CopyableRandomAccessRange>::type> temp(
+ adaptors::slice(rng, t, u));
return CopyableRandomAccessRange( temp.begin(), temp.end() );
- }
- } // 'adaptors'
+ }
+ } // 'adaptors'
}
Modified: trunk/boost/range/adaptor/filtered.hpp
==============================================================================
--- trunk/boost/range/adaptor/filtered.hpp (original)
+++ trunk/boost/range/adaptor/filtered.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -17,84 +17,84 @@
namespace boost
{
- namespace range_detail
- {
- template< class P, class R >
- struct filter_range :
+ namespace range_detail
+ {
+ template< class P, class R >
+ struct filter_range :
boost::iterator_range<
boost::filter_iterator< P,
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
>
>
- {
- private:
- typedef boost::iterator_range<
+ {
+ private:
+ typedef boost::iterator_range<
boost::filter_iterator< P,
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
>
> base;
- public:
- filter_range( P p, R& r )
- : base( make_filter_iterator( p, boost::begin(r), boost::end(r) ),
- make_filter_iterator( p, boost::end(r), boost::end(r) ) )
- { }
- };
-
- template< class T >
- struct filter_holder : holder<T>
- {
- filter_holder( T r ) : holder<T>(r)
- { }
- };
-
- template< class InputRng, class Predicate >
- inline filter_range<Predicate, InputRng>
- operator|( InputRng& r,
- const filter_holder<Predicate>& f )
- {
- return filter_range<Predicate, InputRng>( f.val, r );
- }
-
- template< class InputRng, class Predicate >
- inline filter_range<Predicate, const InputRng>
- operator|( const InputRng& r,
- const filter_holder<Predicate>& f )
- {
- return filter_range<Predicate, const InputRng>( f.val, r );
- }
-
- } // 'range_detail'
-
- // Unusual use of 'using' is intended to bring filter_range into the boost namespace
- // while leaving the mechanics of the '|' operator in range_detail and maintain
- // argument dependent lookup.
- // filter_range logically needs to be in the boost namespace to allow user of
- // the library to define the return type for filter()
- using range_detail::filter_range;
-
- namespace adaptors
- {
- namespace
- {
- const range_detail::forwarder<range_detail::filter_holder>
- filtered =
- range_detail::forwarder<range_detail::filter_holder>();
- }
-
- template<class InputRange, class Predicate>
- inline filter_range<Predicate, InputRange>
- filter(InputRange& rng, Predicate filter_pred)
- {
- return range_detail::filter_range<Predicate, InputRange>( filter_pred, rng );
- }
-
- template<class InputRange, class Predicate>
- inline filter_range<Predicate, const InputRange>
- filter(const InputRange& rng, Predicate filter_pred)
- {
- return range_detail::filter_range<Predicate, const InputRange>( filter_pred, rng );
+ public:
+ filter_range( P p, R& r )
+ : base( make_filter_iterator( p, boost::begin(r), boost::end(r) ),
+ make_filter_iterator( p, boost::end(r), boost::end(r) ) )
+ { }
+ };
+
+ template< class T >
+ struct filter_holder : holder<T>
+ {
+ filter_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ template< class InputRng, class Predicate >
+ inline filter_range<Predicate, InputRng>
+ operator|( InputRng& r,
+ const filter_holder<Predicate>& f )
+ {
+ return filter_range<Predicate, InputRng>( f.val, r );
}
- } // 'adaptors'
+
+ template< class InputRng, class Predicate >
+ inline filter_range<Predicate, const InputRng>
+ operator|( const InputRng& r,
+ const filter_holder<Predicate>& f )
+ {
+ return filter_range<Predicate, const InputRng>( f.val, r );
+ }
+
+ } // 'range_detail'
+
+ // Unusual use of 'using' is intended to bring filter_range into the boost namespace
+ // while leaving the mechanics of the '|' operator in range_detail and maintain
+ // argument dependent lookup.
+ // filter_range logically needs to be in the boost namespace to allow user of
+ // the library to define the return type for filter()
+ using range_detail::filter_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder<range_detail::filter_holder>
+ filtered =
+ range_detail::forwarder<range_detail::filter_holder>();
+ }
+
+ template<class InputRange, class Predicate>
+ inline filter_range<Predicate, InputRange>
+ filter(InputRange& rng, Predicate filter_pred)
+ {
+ return range_detail::filter_range<Predicate, InputRange>( filter_pred, rng );
+ }
+
+ template<class InputRange, class Predicate>
+ inline filter_range<Predicate, const InputRange>
+ filter(const InputRange& rng, Predicate filter_pred)
+ {
+ return range_detail::filter_range<Predicate, const InputRange>( filter_pred, rng );
+ }
+ } // 'adaptors'
}
Modified: trunk/boost/range/adaptor/indexed.hpp
==============================================================================
--- trunk/boost/range/adaptor/indexed.hpp (original)
+++ trunk/boost/range/adaptor/indexed.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -40,56 +40,56 @@
};
}
- namespace range_detail
- {
- template< class Iter >
- class indexed_iterator
- : public boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
- {
- private:
- typedef boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
- base;
-
- typedef BOOST_DEDUCED_TYPENAME base::difference_type index_type;
-
- index_type m_index;
-
- public:
- explicit indexed_iterator( Iter i, index_type index )
- : base(i), m_index(index)
- {
- BOOST_ASSERT( m_index >= 0 && "Indexed Iterator out of bounds" );
- }
-
- index_type index() const
- {
- return m_index;
- }
+ namespace range_detail
+ {
+ template< class Iter >
+ class indexed_iterator
+ : public boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
+ {
+ private:
+ typedef boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
+ base;
- private:
- friend class boost::iterator_core_access;
+ typedef BOOST_DEDUCED_TYPENAME base::difference_type index_type;
- void increment()
- {
+ index_type m_index;
+
+ public:
+ explicit indexed_iterator( Iter i, index_type index )
+ : base(i), m_index(index)
+ {
+ BOOST_ASSERT( m_index >= 0 && "Indexed Iterator out of bounds" );
+ }
+
+ index_type index() const
+ {
+ return m_index;
+ }
+
+ private:
+ friend class boost::iterator_core_access;
+
+ void increment()
+ {
++m_index;
++(this->base_reference());
- }
+ }
- void decrement()
+ void decrement()
{
BOOST_ASSERT( m_index > 0 && "Indexed Iterator out of bounds" );
--m_index;
--(this->base_reference());
}
- void advance( index_type n )
+ void advance( index_type n )
{
m_index += n;
BOOST_ASSERT( m_index >= 0 && "Indexed Iterator out of bounds" );
this->base_reference() += n;
}
- };
+ };
template< class Rng >
struct indexed_range :
@@ -107,45 +107,45 @@
{ }
};
- } // 'range_detail'
+ } // 'range_detail'
- // Make this available to users of this library. It will sometimes be
- // required since it is the return type of operator '|' and
- // index().
- using range_detail::indexed_range;
+ // Make this available to users of this library. It will sometimes be
+ // required since it is the return type of operator '|' and
+ // index().
+ using range_detail::indexed_range;
- namespace adaptors
- {
+ namespace adaptors
+ {
template< class SinglePassRange >
- inline indexed_range<SinglePassRange>
- operator|( SinglePassRange& r,
- const indexed& f )
- {
- return indexed_range<SinglePassRange>( f.val, r );
- }
-
- template< class SinglePassRange >
- inline indexed_range<const SinglePassRange>
- operator|( const SinglePassRange& r,
- const indexed& f )
- {
- return indexed_range<const SinglePassRange>( f.val, r );
- }
-
- template<class SinglePassRange, class Index>
- inline indexed_range<SinglePassRange>
- index(SinglePassRange& rng, Index index_value)
- {
- return indexed_range<SinglePassRange>(index_value, rng);
- }
-
- template<class SinglePassRange, class Index>
- inline indexed_range<const SinglePassRange>
- index(const SinglePassRange& rng, Index index_value)
- {
- return indexed_range<const SinglePassRange>(index_value, rng);
+ inline indexed_range<SinglePassRange>
+ operator|( SinglePassRange& r,
+ const indexed& f )
+ {
+ return indexed_range<SinglePassRange>( f.val, r );
+ }
+
+ template< class SinglePassRange >
+ inline indexed_range<const SinglePassRange>
+ operator|( const SinglePassRange& r,
+ const indexed& f )
+ {
+ return indexed_range<const SinglePassRange>( f.val, r );
+ }
+
+ template<class SinglePassRange, class Index>
+ inline indexed_range<SinglePassRange>
+ index(SinglePassRange& rng, Index index_value)
+ {
+ return indexed_range<SinglePassRange>(index_value, rng);
+ }
+
+ template<class SinglePassRange, class Index>
+ inline indexed_range<const SinglePassRange>
+ index(const SinglePassRange& rng, Index index_value)
+ {
+ return indexed_range<const SinglePassRange>(index_value, rng);
}
- } // 'adaptors'
+ } // 'adaptors'
}
Modified: trunk/boost/range/adaptor/indirected.hpp
==============================================================================
--- trunk/boost/range/adaptor/indirected.hpp (original)
+++ trunk/boost/range/adaptor/indirected.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -16,72 +16,72 @@
namespace boost
{
- namespace range_detail
- {
- template< class R >
- struct indirect_range :
- public boost::iterator_range<
+ namespace range_detail
+ {
+ template< class R >
+ struct indirect_range :
+ public boost::iterator_range<
boost::indirect_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
>
>
- {
- private:
- typedef boost::iterator_range<
+ {
+ private:
+ typedef boost::iterator_range<
boost::indirect_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
>
>
- base;
+ base;
- public:
- explicit indirect_range( R& r )
+ public:
+ explicit indirect_range( R& r )
: base( r )
- { }
- };
+ { }
+ };
- struct indirect_forwarder {};
+ struct indirect_forwarder {};
- template< class InputRng >
- inline indirect_range<InputRng>
- operator|( InputRng& r, indirect_forwarder )
- {
- return indirect_range<InputRng>( r );
- }
-
- template< class InputRng >
- inline indirect_range<const InputRng>
- operator|( const InputRng& r, indirect_forwarder )
- {
- return indirect_range<const InputRng>( r );
- }
-
- } // 'range_detail'
-
- using range_detail::indirect_range;
-
- namespace adaptors
- {
- namespace
- {
- const range_detail::indirect_forwarder indirected =
- range_detail::indirect_forwarder();
- }
-
- template<class InputRange>
- inline indirect_range<InputRange>
- indirect(InputRange& rng)
- {
- return indirect_range<InputRange>(rng);
- }
-
- template<class InputRange>
- inline indirect_range<const InputRange>
- indirect(const InputRange& rng)
- {
- return indirect_range<const InputRange>(rng);
- }
- } // 'adaptors'
+ template< class InputRng >
+ inline indirect_range<InputRng>
+ operator|( InputRng& r, indirect_forwarder )
+ {
+ return indirect_range<InputRng>( r );
+ }
+
+ template< class InputRng >
+ inline indirect_range<const InputRng>
+ operator|( const InputRng& r, indirect_forwarder )
+ {
+ return indirect_range<const InputRng>( r );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::indirect_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::indirect_forwarder indirected =
+ range_detail::indirect_forwarder();
+ }
+
+ template<class InputRange>
+ inline indirect_range<InputRange>
+ indirect(InputRange& rng)
+ {
+ return indirect_range<InputRange>(rng);
+ }
+
+ template<class InputRange>
+ inline indirect_range<const InputRange>
+ indirect(const InputRange& rng)
+ {
+ return indirect_range<const InputRange>(rng);
+ }
+ } // 'adaptors'
}
Modified: trunk/boost/range/adaptor/map.hpp
==============================================================================
--- trunk/boost/range/adaptor/map.hpp (original)
+++ trunk/boost/range/adaptor/map.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -17,161 +17,161 @@
namespace boost
{
- namespace range_detail
- {
- struct map_keys_forwarder {};
- struct map_values_forwarder {};
-
- template< class Map >
- struct select_first
- {
- typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
- typedef const BOOST_DEDUCED_TYPENAME pair_t::first_type&
- result_type;
-
- result_type operator()( const pair_t& r ) const
- {
- return r.first;
- }
- };
-
- template< class Map >
- struct select_second_mutable
- {
- typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
- typedef BOOST_DEDUCED_TYPENAME pair_t::second_type& result_type;
-
- result_type operator()( pair_t& r ) const
- {
- return r.second;
- }
- };
-
- template< class Map >
- struct select_second_const
- {
- typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
- typedef const BOOST_DEDUCED_TYPENAME pair_t::second_type&
- result_type;
-
- result_type operator()( const pair_t& r ) const
- {
- return r.second;
- }
- };
-
- template<class StdPairRng>
- class select_first_range
- : public transform_range<
- select_first<StdPairRng>,
- const StdPairRng>
- {
- typedef transform_range<select_first<StdPairRng>, const StdPairRng> base;
- public:
- typedef select_first<StdPairRng> transform_fn_type;
- typedef const StdPairRng source_range_type;
-
- select_first_range(transform_fn_type fn, source_range_type& rng)
- : base(fn, rng)
- {
- }
-
- select_first_range(const base& other) : base(other) {}
- };
-
- template<class StdPairRng>
- class select_second_mutable_range
- : public transform_range<
- select_second_mutable<StdPairRng>,
- StdPairRng>
- {
- typedef transform_range<select_second_mutable<StdPairRng>, StdPairRng> base;
- public:
- typedef select_second_mutable<StdPairRng> transform_fn_type;
- typedef StdPairRng source_range_type;
-
- select_second_mutable_range(transform_fn_type fn, source_range_type& rng)
- : base(fn, rng)
- {
- }
-
- select_second_mutable_range(const base& other) : base(other) {}
- };
-
- template<class StdPairRng>
- class select_second_const_range
- : public transform_range<
- select_second_const<StdPairRng>,
- const StdPairRng>
- {
- typedef transform_range<select_second_const<StdPairRng>, const StdPairRng> base;
- public:
- typedef select_second_const<StdPairRng> transform_fn_type;
- typedef const StdPairRng source_range_type;
-
- select_second_const_range(transform_fn_type fn, source_range_type& rng)
- : base(fn, rng)
- {
- }
-
- select_second_const_range(const base& other) : base(other) {}
- };
-
- template< class StdPairRng >
- inline select_first_range<StdPairRng>
- operator|( const StdPairRng& r, map_keys_forwarder )
- {
- return operator|( r,
- boost::adaptors::transformed( select_first<StdPairRng>() ) );
- }
-
- template< class StdPairRng >
- inline select_second_mutable_range<StdPairRng>
- operator|( StdPairRng& r, map_values_forwarder )
- {
- return operator|( r,
- boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
- }
-
- template< class StdPairRng >
- inline select_second_const_range<StdPairRng>
- operator|( const StdPairRng& r, map_values_forwarder )
- {
- return operator|( r,
- boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
- }
-
- } // 'range_detail'
-
- using range_detail::select_first_range;
- using range_detail::select_second_mutable_range;
- using range_detail::select_second_const_range;
-
- namespace adaptors
- {
- namespace
- {
- const range_detail::map_keys_forwarder map_keys =
- range_detail::map_keys_forwarder();
-
- const range_detail::map_values_forwarder map_values =
- range_detail::map_values_forwarder();
- }
-
- template<class StdPairRange>
- inline select_first_range<StdPairRange>
- keys(const StdPairRange& rng)
- {
- return select_first_range<StdPairRange>(
- range_detail::select_first<StdPairRange>(), rng );
- }
-
- template<class StdPairRange>
- inline select_second_const_range<StdPairRange>
- values(const StdPairRange& rng)
- {
- return select_second_const_range<StdPairRange>(
- range_detail::select_second_const<StdPairRange>(), rng );
+ namespace range_detail
+ {
+ struct map_keys_forwarder {};
+ struct map_values_forwarder {};
+
+ template< class Map >
+ struct select_first
+ {
+ typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
+ typedef const BOOST_DEDUCED_TYPENAME pair_t::first_type&
+ result_type;
+
+ result_type operator()( const pair_t& r ) const
+ {
+ return r.first;
+ }
+ };
+
+ template< class Map >
+ struct select_second_mutable
+ {
+ typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
+ typedef BOOST_DEDUCED_TYPENAME pair_t::second_type& result_type;
+
+ result_type operator()( pair_t& r ) const
+ {
+ return r.second;
+ }
+ };
+
+ template< class Map >
+ struct select_second_const
+ {
+ typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
+ typedef const BOOST_DEDUCED_TYPENAME pair_t::second_type&
+ result_type;
+
+ result_type operator()( const pair_t& r ) const
+ {
+ return r.second;
+ }
+ };
+
+ template<class StdPairRng>
+ class select_first_range
+ : public transform_range<
+ select_first<StdPairRng>,
+ const StdPairRng>
+ {
+ typedef transform_range<select_first<StdPairRng>, const StdPairRng> base;
+ public:
+ typedef select_first<StdPairRng> transform_fn_type;
+ typedef const StdPairRng source_range_type;
+
+ select_first_range(transform_fn_type fn, source_range_type& rng)
+ : base(fn, rng)
+ {
+ }
+
+ select_first_range(const base& other) : base(other) {}
+ };
+
+ template<class StdPairRng>
+ class select_second_mutable_range
+ : public transform_range<
+ select_second_mutable<StdPairRng>,
+ StdPairRng>
+ {
+ typedef transform_range<select_second_mutable<StdPairRng>, StdPairRng> base;
+ public:
+ typedef select_second_mutable<StdPairRng> transform_fn_type;
+ typedef StdPairRng source_range_type;
+
+ select_second_mutable_range(transform_fn_type fn, source_range_type& rng)
+ : base(fn, rng)
+ {
+ }
+
+ select_second_mutable_range(const base& other) : base(other) {}
+ };
+
+ template<class StdPairRng>
+ class select_second_const_range
+ : public transform_range<
+ select_second_const<StdPairRng>,
+ const StdPairRng>
+ {
+ typedef transform_range<select_second_const<StdPairRng>, const StdPairRng> base;
+ public:
+ typedef select_second_const<StdPairRng> transform_fn_type;
+ typedef const StdPairRng source_range_type;
+
+ select_second_const_range(transform_fn_type fn, source_range_type& rng)
+ : base(fn, rng)
+ {
+ }
+
+ select_second_const_range(const base& other) : base(other) {}
+ };
+
+ template< class StdPairRng >
+ inline select_first_range<StdPairRng>
+ operator|( const StdPairRng& r, map_keys_forwarder )
+ {
+ return operator|( r,
+ boost::adaptors::transformed( select_first<StdPairRng>() ) );
+ }
+
+ template< class StdPairRng >
+ inline select_second_mutable_range<StdPairRng>
+ operator|( StdPairRng& r, map_values_forwarder )
+ {
+ return operator|( r,
+ boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
+ }
+
+ template< class StdPairRng >
+ inline select_second_const_range<StdPairRng>
+ operator|( const StdPairRng& r, map_values_forwarder )
+ {
+ return operator|( r,
+ boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::select_first_range;
+ using range_detail::select_second_mutable_range;
+ using range_detail::select_second_const_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::map_keys_forwarder map_keys =
+ range_detail::map_keys_forwarder();
+
+ const range_detail::map_values_forwarder map_values =
+ range_detail::map_values_forwarder();
+ }
+
+ template<class StdPairRange>
+ inline select_first_range<StdPairRange>
+ keys(const StdPairRange& rng)
+ {
+ return select_first_range<StdPairRange>(
+ range_detail::select_first<StdPairRange>(), rng );
+ }
+
+ template<class StdPairRange>
+ inline select_second_const_range<StdPairRange>
+ values(const StdPairRange& rng)
+ {
+ return select_second_const_range<StdPairRange>(
+ range_detail::select_second_const<StdPairRange>(), rng );
}
template<class StdPairRange>
@@ -181,8 +181,8 @@
return select_second_mutable_range<StdPairRange>(
range_detail::select_second_mutable<StdPairRange>(), rng );
}
- } // 'adaptors'
-
+ } // 'adaptors'
+
}
#endif
Modified: trunk/boost/range/adaptor/replaced.hpp
==============================================================================
--- trunk/boost/range/adaptor/replaced.hpp (original)
+++ trunk/boost/range/adaptor/replaced.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -22,99 +22,99 @@
namespace boost
{
- namespace range_detail
- {
- template< class Value >
- class replace_value
- {
- public:
- typedef const Value& result_type;
- typedef const Value& first_argument_type;
-
- replace_value(const Value& from, const Value& to)
- : m_from(from), m_to(to)
- {
- }
-
- const Value& operator()(const Value& x) const
- {
- return (x == m_from) ? m_to : x;
- }
-
- private:
- Value m_from;
- Value m_to;
- };
-
- template< class R >
- class replace_range :
- public boost::iterator_range<
- boost::transform_iterator<
- replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
- {
- private:
- typedef replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
-
- typedef boost::iterator_range<
- boost::transform_iterator<
- replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
-
- public:
- typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
-
- replace_range( R& r, value_type from, value_type to )
- : base_t( make_transform_iterator( boost::begin(r), Fn(from, to) ),
- make_transform_iterator( boost::end(r), Fn(from, to) ) )
- { }
- };
-
- template< class T >
- class replace_holder : public holder2<T>
- {
- public:
- replace_holder( const T& from, const T& to )
- : holder2<T>(from, to)
- { }
- private:
- // not assignable
- void operator=(const replace_holder&);
- };
-
- template< class InputRng >
- inline replace_range<InputRng>
- operator|( InputRng& r,
- const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
- {
- return replace_range<InputRng>(r, f.val1, f.val2);
- }
-
- template< class InputRng >
- inline replace_range<const InputRng>
- operator|( const InputRng& r,
- const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
- {
- return replace_range<const InputRng>(r, f.val1, f.val2);
- }
- } // 'range_detail'
+ namespace range_detail
+ {
+ template< class Value >
+ class replace_value
+ {
+ public:
+ typedef const Value& result_type;
+ typedef const Value& first_argument_type;
+
+ replace_value(const Value& from, const Value& to)
+ : m_from(from), m_to(to)
+ {
+ }
+
+ const Value& operator()(const Value& x) const
+ {
+ return (x == m_from) ? m_to : x;
+ }
+
+ private:
+ Value m_from;
+ Value m_to;
+ };
+
+ template< class R >
+ class replace_range :
+ public boost::iterator_range<
+ boost::transform_iterator<
+ replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
+ {
+ private:
+ typedef replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
+
+ typedef boost::iterator_range<
+ boost::transform_iterator<
+ replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
+
+ replace_range( R& r, value_type from, value_type to )
+ : base_t( make_transform_iterator( boost::begin(r), Fn(from, to) ),
+ make_transform_iterator( boost::end(r), Fn(from, to) ) )
+ { }
+ };
+
+ template< class T >
+ class replace_holder : public holder2<T>
+ {
+ public:
+ replace_holder( const T& from, const T& to )
+ : holder2<T>(from, to)
+ { }
+ private:
+ // not assignable
+ void operator=(const replace_holder&);
+ };
+
+ template< class InputRng >
+ inline replace_range<InputRng>
+ operator|( InputRng& r,
+ const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
+ {
+ return replace_range<InputRng>(r, f.val1, f.val2);
+ }
+
+ template< class InputRng >
+ inline replace_range<const InputRng>
+ operator|( const InputRng& r,
+ const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
+ {
+ return replace_range<const InputRng>(r, f.val1, f.val2);
+ }
+ } // 'range_detail'
using range_detail::replace_range;
- namespace adaptors
- {
- namespace
- {
- const range_detail::forwarder2<range_detail::replace_holder>
- replaced =
- range_detail::forwarder2<range_detail::replace_holder>();
- }
-
- template<class InputRange>
- inline replace_range<InputRange>
- replace(InputRange& rng,
- BOOST_DEDUCED_TYPENAME range_value<InputRange>::type from,
- BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder2<range_detail::replace_holder>
+ replaced =
+ range_detail::forwarder2<range_detail::replace_holder>();
+ }
+
+ template<class InputRange>
+ inline replace_range<InputRange>
+ replace(InputRange& rng,
+ BOOST_DEDUCED_TYPENAME range_value<InputRange>::type from,
+ BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
{
return replace_range<InputRange>(rng, from, to);
}
@@ -128,7 +128,7 @@
return replace_range<const InputRange>(rng, from ,to);
}
- } // 'adaptors'
+ } // 'adaptors'
} // 'boost'
#endif // include guard
Modified: trunk/boost/range/adaptor/replaced_if.hpp
==============================================================================
--- trunk/boost/range/adaptor/replaced_if.hpp (original)
+++ trunk/boost/range/adaptor/replaced_if.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -22,115 +22,115 @@
namespace boost
{
- namespace range_detail
- {
- template< class Pred, class Value >
- class replace_value_if
- {
- public:
- typedef const Value& result_type;
- typedef const Value& first_argument_type;
-
- replace_value_if(const Pred& pred, const Value& to)
- : m_pred(pred), m_to(to)
- {
- }
-
- const Value& operator()(const Value& x) const
- {
- return m_pred(x) ? m_to : x;
- }
-
- private:
- Pred m_pred;
- Value m_to;
- };
-
- template< class Pred, class R >
- class replace_if_range :
- public boost::iterator_range<
- boost::transform_iterator<
- replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
- {
- private:
- typedef replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
-
- typedef boost::iterator_range<
- boost::transform_iterator<
- replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
-
- public:
- typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
-
- replace_if_range( R& r, const Pred& pred, value_type to )
- : base_t( make_transform_iterator( boost::begin(r), Fn(pred, to) ),
- make_transform_iterator( boost::end(r), Fn(pred, to) ) )
- { }
- };
-
- template< class Pred, class T >
- class replace_if_holder
- {
- public:
- replace_if_holder( const Pred& pred, const T& to )
- : m_pred(pred), m_to(to)
- { }
-
- const Pred& pred() const { return m_pred; }
- const T& to() const { return m_to; }
-
- private:
- Pred m_pred;
- T m_to;
- };
-
- template< class Pred, class InputRng >
- inline replace_if_range<Pred, InputRng>
- operator|( InputRng& r,
- const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
- {
- return replace_if_range<Pred, InputRng>(r, f.pred(), f.to());
- }
-
- template< class Pred, class InputRng >
- inline replace_if_range<Pred, const InputRng>
- operator|( const InputRng& r,
- const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
- {
- return replace_if_range<Pred, const InputRng>(r, f.pred(), f.to());
- }
- } // 'range_detail'
+ namespace range_detail
+ {
+ template< class Pred, class Value >
+ class replace_value_if
+ {
+ public:
+ typedef const Value& result_type;
+ typedef const Value& first_argument_type;
+
+ replace_value_if(const Pred& pred, const Value& to)
+ : m_pred(pred), m_to(to)
+ {
+ }
+
+ const Value& operator()(const Value& x) const
+ {
+ return m_pred(x) ? m_to : x;
+ }
+
+ private:
+ Pred m_pred;
+ Value m_to;
+ };
+
+ template< class Pred, class R >
+ class replace_if_range :
+ public boost::iterator_range<
+ boost::transform_iterator<
+ replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
+ {
+ private:
+ typedef replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
+
+ typedef boost::iterator_range<
+ boost::transform_iterator<
+ replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
+
+ replace_if_range( R& r, const Pred& pred, value_type to )
+ : base_t( make_transform_iterator( boost::begin(r), Fn(pred, to) ),
+ make_transform_iterator( boost::end(r), Fn(pred, to) ) )
+ { }
+ };
+
+ template< class Pred, class T >
+ class replace_if_holder
+ {
+ public:
+ replace_if_holder( const Pred& pred, const T& to )
+ : m_pred(pred), m_to(to)
+ { }
+
+ const Pred& pred() const { return m_pred; }
+ const T& to() const { return m_to; }
+
+ private:
+ Pred m_pred;
+ T m_to;
+ };
+
+ template< class Pred, class InputRng >
+ inline replace_if_range<Pred, InputRng>
+ operator|( InputRng& r,
+ const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
+ {
+ return replace_if_range<Pred, InputRng>(r, f.pred(), f.to());
+ }
+
+ template< class Pred, class InputRng >
+ inline replace_if_range<Pred, const InputRng>
+ operator|( const InputRng& r,
+ const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
+ {
+ return replace_if_range<Pred, const InputRng>(r, f.pred(), f.to());
+ }
+ } // 'range_detail'
using range_detail::replace_if_range;
- namespace adaptors
- {
- namespace
- {
- const range_detail::forwarder2TU<range_detail::replace_if_holder>
- replaced_if =
- range_detail::forwarder2TU<range_detail::replace_if_holder>();
- }
-
- template<class Pred, class InputRange>
- inline replace_if_range<Pred, InputRange>
- replace_if(InputRange& rng, Pred pred,
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder2TU<range_detail::replace_if_holder>
+ replaced_if =
+ range_detail::forwarder2TU<range_detail::replace_if_holder>();
+ }
+
+ template<class Pred, class InputRange>
+ inline replace_if_range<Pred, InputRange>
+ replace_if(InputRange& rng, Pred pred,
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
- {
- return range_detail::replace_if_range<Pred, InputRange>(rng, pred, to);
- }
-
- template<class Pred, class InputRange>
- inline replace_if_range<Pred, const InputRange>
- replace_if(const InputRange& rng, Pred pred,
- BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type to)
- {
- return range_detail::replace_if_range<Pred, const InputRange>(rng, pred, to);
- }
- } // 'adaptors'
-
+ {
+ return range_detail::replace_if_range<Pred, InputRange>(rng, pred, to);
+ }
+
+ template<class Pred, class InputRange>
+ inline replace_if_range<Pred, const InputRange>
+ replace_if(const InputRange& rng, Pred pred,
+ BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type to)
+ {
+ return range_detail::replace_if_range<Pred, const InputRange>(rng, pred, to);
+ }
+ } // 'adaptors'
+
} // 'boost'
#endif // include guard
Modified: trunk/boost/range/adaptor/reversed.hpp
==============================================================================
--- trunk/boost/range/adaptor/reversed.hpp (original)
+++ trunk/boost/range/adaptor/reversed.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -16,75 +16,75 @@
namespace boost
{
- namespace range_detail
- {
- template< class R >
- struct reverse_range :
- public boost::iterator_range<
- boost::reverse_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type
- >
- >
- {
- private:
- typedef boost::iterator_range<
- boost::reverse_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type
- >
- >
- base;
-
- public:
- typedef boost::reverse_iterator<BOOST_DEDUCED_TYPENAME range_iterator<R>::type> iterator;
+ namespace range_detail
+ {
+ template< class R >
+ struct reverse_range :
+ public boost::iterator_range<
+ boost::reverse_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef boost::iterator_range<
+ boost::reverse_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ base;
+
+ public:
+ typedef boost::reverse_iterator<BOOST_DEDUCED_TYPENAME range_iterator<R>::type> iterator;
- reverse_range( R& r )
- : base( iterator(boost::end(r)), iterator(boost::begin(r)) )
- { }
- };
+ reverse_range( R& r )
+ : base( iterator(boost::end(r)), iterator(boost::begin(r)) )
+ { }
+ };
- struct reverse_forwarder {};
-
- template< class BidirectionalRng >
- inline reverse_range<BidirectionalRng>
- operator|( BidirectionalRng& r, reverse_forwarder )
- {
- return reverse_range<BidirectionalRng>( r );
- }
-
- template< class BidirectionalRng >
- inline reverse_range<const BidirectionalRng>
- operator|( const BidirectionalRng& r, reverse_forwarder )
- {
- return reverse_range<const BidirectionalRng>( r );
- }
-
- } // 'range_detail'
-
- using range_detail::reverse_range;
+ struct reverse_forwarder {};
+
+ template< class BidirectionalRng >
+ inline reverse_range<BidirectionalRng>
+ operator|( BidirectionalRng& r, reverse_forwarder )
+ {
+ return reverse_range<BidirectionalRng>( r );
+ }
+
+ template< class BidirectionalRng >
+ inline reverse_range<const BidirectionalRng>
+ operator|( const BidirectionalRng& r, reverse_forwarder )
+ {
+ return reverse_range<const BidirectionalRng>( r );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::reverse_range;
- namespace adaptors
- {
- namespace
- {
- const range_detail::reverse_forwarder reversed =
- range_detail::reverse_forwarder();
- }
-
- template<class BidirectionalRange>
- inline reverse_range<BidirectionalRange>
- reverse(BidirectionalRange& rng)
- {
- return reverse_range<BidirectionalRange>(rng);
- }
-
- template<class BidirectionalRange>
- inline reverse_range<const BidirectionalRange>
- reverse(const BidirectionalRange& rng)
- {
- return reverse_range<const BidirectionalRange>(rng);
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::reverse_forwarder reversed =
+ range_detail::reverse_forwarder();
+ }
+
+ template<class BidirectionalRange>
+ inline reverse_range<BidirectionalRange>
+ reverse(BidirectionalRange& rng)
+ {
+ return reverse_range<BidirectionalRange>(rng);
+ }
+
+ template<class BidirectionalRange>
+ inline reverse_range<const BidirectionalRange>
+ reverse(const BidirectionalRange& rng)
+ {
+ return reverse_range<const BidirectionalRange>(rng);
}
- } // 'adaptors'
-
+ } // 'adaptors'
+
} // 'boost'
#endif
Modified: trunk/boost/range/adaptor/sliced.hpp
==============================================================================
--- trunk/boost/range/adaptor/sliced.hpp (original)
+++ trunk/boost/range/adaptor/sliced.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -27,24 +27,24 @@
std::size_t u;
};
- template< class RandomAccessRange >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
- slice( RandomAccessRange& rng, std::size_t t, std::size_t u )
- {
- BOOST_ASSERT( t <= u && "error in slice indices" );
+ template< class RandomAccessRange >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
+ slice( RandomAccessRange& rng, std::size_t t, std::size_t u )
+ {
+ BOOST_ASSERT( t <= u && "error in slice indices" );
BOOST_ASSERT( static_cast<std::size_t>(boost::size(rng)) >= u &&
- "second slice index out of bounds" );
+ "second slice index out of bounds" );
- return boost::make_iterator_range( rng, t, u - boost::size(rng) );
- }
+ return boost::make_iterator_range( rng, t, u - boost::size(rng) );
+ }
- template< class RandomAccessRange >
- inline iterator_range<
- BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
- operator|( RandomAccessRange& r, const sliced& f )
- {
- return adaptors::slice( r, f.t, f.u );
- }
+ template< class RandomAccessRange >
+ inline iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
+ operator|( RandomAccessRange& r, const sliced& f )
+ {
+ return adaptors::slice( r, f.t, f.u );
+ }
} // namespace adaptors
} // namespace boost
Modified: trunk/boost/range/adaptor/strided.hpp
==============================================================================
--- trunk/boost/range/adaptor/strided.hpp (original)
+++ trunk/boost/range/adaptor/strided.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -18,132 +18,132 @@
namespace boost
{
- namespace range_detail
- {
+ namespace range_detail
+ {
- template<typename BaseIterator>
- class strided_iterator
- : public iterator_adaptor<
- strided_iterator<BaseIterator>,
- BaseIterator>
- {
- friend class iterator_core_access;
-
- typedef iterator_adaptor<strided_iterator<BaseIterator>, BaseIterator> super_t;
-
- public:
- typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type difference_type;
-
- strided_iterator() : m_stride() { }
-
- strided_iterator(const strided_iterator& other)
- : super_t(other), m_stride(other.m_stride) { }
-
- explicit strided_iterator(BaseIterator base_it, difference_type stride)
- : super_t(base_it), m_stride(stride) { }
-
- strided_iterator&
- operator=(const strided_iterator& other)
- {
- super_t::operator=(other);
-
- // Is the interoperation of the stride safe?
- m_stride = other.m_stride;
- return *this;
- }
-
- void increment() { std::advance(this->base_reference(), m_stride); }
-
- void decrement() { std::advance(this->base_reference(), -m_stride); }
-
- void advance(difference_type n) { std::advance(this->base_reference(), n * m_stride); }
-
- difference_type
- distance_to(const strided_iterator& other) const
- {
- return std::distance(this->base_reference(), other.base_reference()) / m_stride;
- }
-
- // Using the compiler generated copy constructor and
- // and assignment operator
-
- private:
- difference_type m_stride;
- };
-
- template<class BaseIterator> inline
- strided_iterator<BaseIterator>
- make_strided_iterator(
- const BaseIterator& first,
- BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type stride)
- {
- return strided_iterator<BaseIterator>(first, stride);
- }
-
- template< class Rng >
- class strided_range
- : public iterator_range<range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> >
- {
- typedef range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> iter_type;
- typedef iterator_range<iter_type> super_t;
- public:
- template< typename Difference >
- strided_range(Difference stride, Rng& rng)
+ template<typename BaseIterator>
+ class strided_iterator
+ : public iterator_adaptor<
+ strided_iterator<BaseIterator>,
+ BaseIterator>
+ {
+ friend class iterator_core_access;
+
+ typedef iterator_adaptor<strided_iterator<BaseIterator>, BaseIterator> super_t;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type difference_type;
+
+ strided_iterator() : m_stride() { }
+
+ strided_iterator(const strided_iterator& other)
+ : super_t(other), m_stride(other.m_stride) { }
+
+ explicit strided_iterator(BaseIterator base_it, difference_type stride)
+ : super_t(base_it), m_stride(stride) { }
+
+ strided_iterator&
+ operator=(const strided_iterator& other)
+ {
+ super_t::operator=(other);
+
+ // Is the interoperation of the stride safe?
+ m_stride = other.m_stride;
+ return *this;
+ }
+
+ void increment() { std::advance(this->base_reference(), m_stride); }
+
+ void decrement() { std::advance(this->base_reference(), -m_stride); }
+
+ void advance(difference_type n) { std::advance(this->base_reference(), n * m_stride); }
+
+ difference_type
+ distance_to(const strided_iterator& other) const
+ {
+ return std::distance(this->base_reference(), other.base_reference()) / m_stride;
+ }
+
+ // Using the compiler generated copy constructor and
+ // and assignment operator
+
+ private:
+ difference_type m_stride;
+ };
+
+ template<class BaseIterator> inline
+ strided_iterator<BaseIterator>
+ make_strided_iterator(
+ const BaseIterator& first,
+ BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type stride)
+ {
+ return strided_iterator<BaseIterator>(first, stride);
+ }
+
+ template< class Rng >
+ class strided_range
+ : public iterator_range<range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> >
+ {
+ typedef range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> iter_type;
+ typedef iterator_range<iter_type> super_t;
+ public:
+ template< typename Difference >
+ strided_range(Difference stride, Rng& rng)
: super_t(make_strided_iterator(boost::begin(rng), stride),
make_strided_iterator(boost::end(rng), stride))
- {
- }
- };
-
- template<class Difference>
- class strided_holder : public holder<Difference>
- {
- public:
- strided_holder(Difference value) : holder<Difference>(value) {}
- };
-
- template<class Rng, class Difference>
- inline strided_range<Rng>
- operator|(Rng& rng, const strided_holder<Difference>& stride)
- {
- return strided_range<Rng>(stride.val, rng);
- }
-
- template<class Rng, class Difference>
- inline strided_range<const Rng>
- operator|(const Rng& rng, const strided_holder<Difference>& stride)
- {
- return strided_range<const Rng>(stride.val, rng);
- }
-
- } // namespace range_detail
-
- using range_detail::strided_range;
-
- namespace adaptors
- {
-
- namespace
- {
- const range_detail::forwarder<range_detail::strided_holder>
- strided = range_detail::forwarder<range_detail::strided_holder>();
- }
-
- template<class Range, class Difference>
- inline strided_range<Range>
- stride(Range& rng, Difference step)
- {
- return strided_range<Range>(step, rng);
- }
-
- template<class Range, class Difference>
- inline strided_range<const Range>
- stride(const Range& rng, Difference step)
- {
- return strided_range<const Range>(step, rng);
+ {
+ }
+ };
+
+ template<class Difference>
+ class strided_holder : public holder<Difference>
+ {
+ public:
+ strided_holder(Difference value) : holder<Difference>(value) {}
+ };
+
+ template<class Rng, class Difference>
+ inline strided_range<Rng>
+ operator|(Rng& rng, const strided_holder<Difference>& stride)
+ {
+ return strided_range<Rng>(stride.val, rng);
+ }
+
+ template<class Rng, class Difference>
+ inline strided_range<const Rng>
+ operator|(const Rng& rng, const strided_holder<Difference>& stride)
+ {
+ return strided_range<const Rng>(stride.val, rng);
+ }
+
+ } // namespace range_detail
+
+ using range_detail::strided_range;
+
+ namespace adaptors
+ {
+
+ namespace
+ {
+ const range_detail::forwarder<range_detail::strided_holder>
+ strided = range_detail::forwarder<range_detail::strided_holder>();
+ }
+
+ template<class Range, class Difference>
+ inline strided_range<Range>
+ stride(Range& rng, Difference step)
+ {
+ return strided_range<Range>(step, rng);
+ }
+
+ template<class Range, class Difference>
+ inline strided_range<const Range>
+ stride(const Range& rng, Difference step)
+ {
+ return strided_range<const Range>(step, rng);
}
- } // namespace 'adaptors'
+ } // namespace 'adaptors'
} // namespace 'boost'
#endif
Modified: trunk/boost/range/adaptor/tokenized.hpp
==============================================================================
--- trunk/boost/range/adaptor/tokenized.hpp (original)
+++ trunk/boost/range/adaptor/tokenized.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -16,122 +16,122 @@
namespace boost
{
- namespace range_detail
- {
+ namespace range_detail
+ {
- template< class R >
- struct token_range :
- public boost::iterator_range<
- boost::regex_token_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type
- >
- >
- {
- private:
- typedef
- boost::regex_token_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type
- >
- regex_iter;
-
- typedef BOOST_DEDUCED_TYPENAME regex_iter::regex_type
- regex_type;
-
- typedef boost::iterator_range<regex_iter>
- base;
-
- public:
- template< class Regex, class Submatch, class Flag >
- token_range( R& r, const Regex& re, const Submatch& sub, Flag f )
- : base( regex_iter( boost::begin(r), boost::end(r),
- regex_type(re), sub, f ),
- regex_iter() )
- { }
- };
-
- template< class T, class U, class V >
- struct regex_holder
- {
- const T& re;
- const U& sub;
- V f;
-
- regex_holder( const T& rex, const U& subm, V flag ) :
- re(rex), sub(subm), f(flag)
- { }
- private:
- // Not assignable
- void operator=(const regex_holder&);
- };
-
- struct regex_forwarder
- {
- template< class Regex >
- regex_holder<Regex,int,regex_constants::match_flag_type>
- operator()( const Regex& re,
- int submatch = 0,
- regex_constants::match_flag_type f =
- regex_constants::match_default ) const
- {
- return regex_holder<Regex,int,
- regex_constants::match_flag_type>( re, submatch, f );
- }
-
- template< class Regex, class Submatch >
- regex_holder<Regex,Submatch,regex_constants::match_flag_type>
- operator()( const Regex& re,
- const Submatch& sub,
- regex_constants::match_flag_type f =
- regex_constants::match_default ) const
- {
- return regex_holder<Regex,Submatch,
- regex_constants::match_flag_type>( re, sub, f );
- }
- };
-
- template< class BidirectionalRng, class R, class S, class F >
- inline token_range<BidirectionalRng>
- operator|( BidirectionalRng& r,
- const regex_holder<R,S,F>& f )
- {
- return token_range<BidirectionalRng>( r, f.re, f.sub, f.f );
- }
-
- template< class BidirectionalRng, class R, class S, class F >
- inline token_range<const BidirectionalRng>
- operator|( const BidirectionalRng& r,
- const regex_holder<R,S,F>& f )
- {
- return token_range<const BidirectionalRng>( r, f.re, f.sub, f.f );
- }
-
- } // 'range_detail'
+ template< class R >
+ struct token_range :
+ public boost::iterator_range<
+ boost::regex_token_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef
+ boost::regex_token_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ regex_iter;
+
+ typedef BOOST_DEDUCED_TYPENAME regex_iter::regex_type
+ regex_type;
+
+ typedef boost::iterator_range<regex_iter>
+ base;
+
+ public:
+ template< class Regex, class Submatch, class Flag >
+ token_range( R& r, const Regex& re, const Submatch& sub, Flag f )
+ : base( regex_iter( boost::begin(r), boost::end(r),
+ regex_type(re), sub, f ),
+ regex_iter() )
+ { }
+ };
+
+ template< class T, class U, class V >
+ struct regex_holder
+ {
+ const T& re;
+ const U& sub;
+ V f;
+
+ regex_holder( const T& rex, const U& subm, V flag ) :
+ re(rex), sub(subm), f(flag)
+ { }
+ private:
+ // Not assignable
+ void operator=(const regex_holder&);
+ };
+
+ struct regex_forwarder
+ {
+ template< class Regex >
+ regex_holder<Regex,int,regex_constants::match_flag_type>
+ operator()( const Regex& re,
+ int submatch = 0,
+ regex_constants::match_flag_type f =
+ regex_constants::match_default ) const
+ {
+ return regex_holder<Regex,int,
+ regex_constants::match_flag_type>( re, submatch, f );
+ }
+
+ template< class Regex, class Submatch >
+ regex_holder<Regex,Submatch,regex_constants::match_flag_type>
+ operator()( const Regex& re,
+ const Submatch& sub,
+ regex_constants::match_flag_type f =
+ regex_constants::match_default ) const
+ {
+ return regex_holder<Regex,Submatch,
+ regex_constants::match_flag_type>( re, sub, f );
+ }
+ };
+
+ template< class BidirectionalRng, class R, class S, class F >
+ inline token_range<BidirectionalRng>
+ operator|( BidirectionalRng& r,
+ const regex_holder<R,S,F>& f )
+ {
+ return token_range<BidirectionalRng>( r, f.re, f.sub, f.f );
+ }
+
+ template< class BidirectionalRng, class R, class S, class F >
+ inline token_range<const BidirectionalRng>
+ operator|( const BidirectionalRng& r,
+ const regex_holder<R,S,F>& f )
+ {
+ return token_range<const BidirectionalRng>( r, f.re, f.sub, f.f );
+ }
+
+ } // 'range_detail'
using range_detail::token_range;
- namespace adaptors
- {
- namespace
- {
- const range_detail::regex_forwarder tokenized =
- range_detail::regex_forwarder();
- }
-
- template<class BidirectionalRange, class Regex, class Submatch, class Flag>
- inline token_range<BidirectionalRange>
- tokenize(BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
- {
- return token_range<BidirectionalRange>(rng, reg, sub, f);
- }
-
- template<class BidirectionalRange, class Regex, class Submatch, class Flag>
- inline token_range<const BidirectionalRange>
- tokenize(const BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
- {
- return token_range<const BidirectionalRange>(rng, reg, sub, f);
- }
- } // 'adaptors'
-
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::regex_forwarder tokenized =
+ range_detail::regex_forwarder();
+ }
+
+ template<class BidirectionalRange, class Regex, class Submatch, class Flag>
+ inline token_range<BidirectionalRange>
+ tokenize(BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
+ {
+ return token_range<BidirectionalRange>(rng, reg, sub, f);
+ }
+
+ template<class BidirectionalRange, class Regex, class Submatch, class Flag>
+ inline token_range<const BidirectionalRange>
+ tokenize(const BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
+ {
+ return token_range<const BidirectionalRange>(rng, reg, sub, f);
+ }
+ } // 'adaptors'
+
}
#endif
Modified: trunk/boost/range/adaptor/transformed.hpp
==============================================================================
--- trunk/boost/range/adaptor/transformed.hpp (original)
+++ trunk/boost/range/adaptor/transformed.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -17,87 +17,87 @@
namespace boost
{
- namespace range_detail
- {
+ namespace range_detail
+ {
- template< class F, class R >
- struct transform_range :
- public boost::iterator_range<
- boost::transform_iterator< F,
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type
- >
- >
- {
- private:
- typedef boost::iterator_range<
- boost::transform_iterator< F,
- BOOST_DEDUCED_TYPENAME range_iterator<R>::type
- >
- >
- base;
-
- public:
- typedef F transform_fn_type;
- typedef R source_range_type;
-
- transform_range( F f, R& r )
- : base( make_transform_iterator( boost::begin(r), f ),
- make_transform_iterator( boost::end(r), f ) )
-
- { }
- };
-
- template< class T >
- struct transform_holder : holder<T>
- {
- transform_holder( T r ) : holder<T>(r)
- { }
- };
-
- template< class InputRng, class UnaryFunction >
- inline transform_range<UnaryFunction,InputRng>
- operator|( InputRng& r,
- const transform_holder<UnaryFunction>& f )
- {
- return transform_range<UnaryFunction,InputRng>( f.val, r );
- }
-
- template< class InputRng, class UnaryFunction >
- inline transform_range<UnaryFunction, const InputRng>
- operator|( const InputRng& r,
- const transform_holder<UnaryFunction>& f )
- {
- return transform_range<UnaryFunction, const InputRng>( f.val, r );
- }
-
- } // 'range_detail'
-
- using range_detail::transform_range;
-
- namespace adaptors
- {
- namespace
- {
- const range_detail::forwarder<range_detail::transform_holder>
- transformed =
+ template< class F, class R >
+ struct transform_range :
+ public boost::iterator_range<
+ boost::transform_iterator< F,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef boost::iterator_range<
+ boost::transform_iterator< F,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ base;
+
+ public:
+ typedef F transform_fn_type;
+ typedef R source_range_type;
+
+ transform_range( F f, R& r )
+ : base( make_transform_iterator( boost::begin(r), f ),
+ make_transform_iterator( boost::end(r), f ) )
+
+ { }
+ };
+
+ template< class T >
+ struct transform_holder : holder<T>
+ {
+ transform_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ template< class InputRng, class UnaryFunction >
+ inline transform_range<UnaryFunction,InputRng>
+ operator|( InputRng& r,
+ const transform_holder<UnaryFunction>& f )
+ {
+ return transform_range<UnaryFunction,InputRng>( f.val, r );
+ }
+
+ template< class InputRng, class UnaryFunction >
+ inline transform_range<UnaryFunction, const InputRng>
+ operator|( const InputRng& r,
+ const transform_holder<UnaryFunction>& f )
+ {
+ return transform_range<UnaryFunction, const InputRng>( f.val, r );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::transform_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder<range_detail::transform_holder>
+ transformed =
range_detail::forwarder<range_detail::transform_holder>();
- }
-
- template<class UnaryFunction, class InputRange>
- inline transform_range<UnaryFunction, InputRange>
- transform(InputRange& rng, UnaryFunction fn)
- {
- return transform_range<UnaryFunction, InputRange>(fn, rng);
- }
-
- template<class UnaryFunction, class InputRange>
- inline transform_range<UnaryFunction, const InputRange>
- transform(const InputRange& rng, UnaryFunction fn)
- {
- return transform_range<UnaryFunction, const InputRange>(fn, rng);
- }
- } // 'adaptors'
-
+ }
+
+ template<class UnaryFunction, class InputRange>
+ inline transform_range<UnaryFunction, InputRange>
+ transform(InputRange& rng, UnaryFunction fn)
+ {
+ return transform_range<UnaryFunction, InputRange>(fn, rng);
+ }
+
+ template<class UnaryFunction, class InputRange>
+ inline transform_range<UnaryFunction, const InputRange>
+ transform(const InputRange& rng, UnaryFunction fn)
+ {
+ return transform_range<UnaryFunction, const InputRange>(fn, rng);
+ }
+ } // 'adaptors'
+
}
#endif
Modified: trunk/boost/range/adaptor/uniqued.hpp
==============================================================================
--- trunk/boost/range/adaptor/uniqued.hpp (original)
+++ trunk/boost/range/adaptor/uniqued.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -16,74 +16,74 @@
namespace boost
{
- namespace range_detail
- {
- struct unique_forwarder { };
-
- struct unique_not_equal_to
- {
- typedef bool result_type;
-
- template< class T >
- bool operator()( const T& l, const T& r ) const
- {
- return !(l == r);
- }
- };
-
- template<class ForwardRng>
- class unique_range : public adjacent_filter_range<unique_not_equal_to, ForwardRng, true>
- {
- typedef adjacent_filter_range<unique_not_equal_to, ForwardRng, true> base;
- public:
- explicit unique_range(ForwardRng& rng)
- : base(unique_not_equal_to(), rng)
- {
- }
- };
-
- template< class ForwardRng >
- inline unique_range<ForwardRng>
- operator|( ForwardRng& r,
- unique_forwarder )
- {
- return unique_range<ForwardRng>(r);
- }
-
- template< class ForwardRng >
- inline unique_range<const ForwardRng>
- operator|( const ForwardRng& r,
- unique_forwarder )
- {
- return unique_range<const ForwardRng>(r);
- }
-
- } // 'range_detail'
-
- using range_detail::unique_range;
-
- namespace adaptors
- {
- namespace
- {
- const range_detail::unique_forwarder uniqued =
- range_detail::unique_forwarder();
- }
-
- template<class ForwardRange>
- inline unique_range<ForwardRange>
- unique(ForwardRange& rng)
- {
- return unique_range<ForwardRange>(rng);
- }
-
- template<class ForwardRange>
- inline unique_range<const ForwardRange>
- unique(const ForwardRange& rng)
- {
- return unique_range<const ForwardRange>(rng);
+ namespace range_detail
+ {
+ struct unique_forwarder { };
+
+ struct unique_not_equal_to
+ {
+ typedef bool result_type;
+
+ template< class T >
+ bool operator()( const T& l, const T& r ) const
+ {
+ return !(l == r);
+ }
+ };
+
+ template<class ForwardRng>
+ class unique_range : public adjacent_filter_range<unique_not_equal_to, ForwardRng, true>
+ {
+ typedef adjacent_filter_range<unique_not_equal_to, ForwardRng, true> base;
+ public:
+ explicit unique_range(ForwardRng& rng)
+ : base(unique_not_equal_to(), rng)
+ {
+ }
+ };
+
+ template< class ForwardRng >
+ inline unique_range<ForwardRng>
+ operator|( ForwardRng& r,
+ unique_forwarder )
+ {
+ return unique_range<ForwardRng>(r);
}
- } // 'adaptors'
+
+ template< class ForwardRng >
+ inline unique_range<const ForwardRng>
+ operator|( const ForwardRng& r,
+ unique_forwarder )
+ {
+ return unique_range<const ForwardRng>(r);
+ }
+
+ } // 'range_detail'
+
+ using range_detail::unique_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::unique_forwarder uniqued =
+ range_detail::unique_forwarder();
+ }
+
+ template<class ForwardRange>
+ inline unique_range<ForwardRange>
+ unique(ForwardRange& rng)
+ {
+ return unique_range<ForwardRange>(rng);
+ }
+
+ template<class ForwardRange>
+ inline unique_range<const ForwardRange>
+ unique(const ForwardRange& rng)
+ {
+ return unique_range<const ForwardRange>(rng);
+ }
+ } // 'adaptors'
}
Modified: trunk/boost/range/algorithm/equal.hpp
==============================================================================
--- trunk/boost/range/algorithm/equal.hpp (original)
+++ trunk/boost/range/algorithm/equal.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -20,7 +20,7 @@
{
// An implementation of equality comparison that is optimized for iterator
// traversal categories less than RandomAccessTraversal.
- template< class SinglePassTraversalReadableIterator1,
+ template< class SinglePassTraversalReadableIterator1,
class SinglePassTraversalReadableIterator2,
class IteratorCategoryTag1,
class IteratorCategoryTag2 >
Modified: trunk/boost/range/algorithm/remove_copy_if.hpp
==============================================================================
--- trunk/boost/range/algorithm/remove_copy_if.hpp (original)
+++ trunk/boost/range/algorithm/remove_copy_if.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -31,7 +31,7 @@
remove_copy_if(SinglePassRange& rng, OutputIterator out_it, Predicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
- return std::remove_copy_if(boost::begin(rng), boost::end(rng), out_it, pred);
+ return std::remove_copy_if(boost::begin(rng), boost::end(rng), out_it, pred);
}
}
Modified: trunk/boost/range/algorithm_ext/for_each.hpp
==============================================================================
--- trunk/boost/range/algorithm_ext/for_each.hpp (original)
+++ trunk/boost/range/algorithm_ext/for_each.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -19,55 +19,55 @@
namespace boost
{
- namespace range_detail
- {
- template<class InputIterator1, class InputIterator2, class Fn2>
- inline Fn2 for_each_impl(InputIterator1 first1, InputIterator1 last1,
- InputIterator2 first2, InputIterator2 last2,
- Fn2 fn)
- {
- for (; first1 != last1 && first2 != last2; ++first1, ++first2)
- {
- fn(*first1, *first2);
- }
- return fn;
- }
- }
-
- namespace range
- {
- template<class SinglePassRange1, class SinglePassRange2, class Fn2>
- inline Fn2 for_each(const SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
- {
- BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ namespace range_detail
+ {
+ template<class InputIterator1, class InputIterator2, class Fn2>
+ inline Fn2 for_each_impl(InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, InputIterator2 last2,
+ Fn2 fn)
+ {
+ for (; first1 != last1 && first2 != last2; ++first1, ++first2)
+ {
+ fn(*first1, *first2);
+ }
+ return fn;
+ }
+ }
+
+ namespace range
+ {
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(const SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
- return ::boost::range_detail::for_each_impl(
+ return ::boost::range_detail::for_each_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), fn);
- }
+ }
- template<class SinglePassRange1, class SinglePassRange2, class Fn2>
- inline Fn2 for_each(const SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
- {
- BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
- BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(const SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
- return ::boost::range_detail::for_each_impl(
+ return ::boost::range_detail::for_each_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), fn);
- }
+ }
- template<class SinglePassRange1, class SinglePassRange2, class Fn2>
- inline Fn2 for_each(SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
- {
- BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
- BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
+ {
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+ BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
- return ::boost::range_detail::for_each_impl(
+ return ::boost::range_detail::for_each_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), fn);
- }
+ }
template<class SinglePassRange1, class SinglePassRange2, class Fn2>
inline Fn2 for_each(SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
@@ -79,8 +79,8 @@
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), fn);
}
- } // namespace range
- using range::for_each;
+ } // namespace range
+ using range::for_each;
} // namespace boost
#endif // include guard
Modified: trunk/boost/range/counting_range.hpp
==============================================================================
--- trunk/boost/range/counting_range.hpp (original)
+++ trunk/boost/range/counting_range.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -25,41 +25,41 @@
namespace boost
{
- template<class Value>
- inline iterator_range<counting_iterator<Value> >
- counting_range(Value first, Value last)
- {
- typedef counting_iterator<Value> counting_iterator_t;
- typedef iterator_range<counting_iterator_t> result_t;
- return result_t(counting_iterator_t(first),
- counting_iterator_t(last));
- }
+ template<class Value>
+ inline iterator_range<counting_iterator<Value> >
+ counting_range(Value first, Value last)
+ {
+ typedef counting_iterator<Value> counting_iterator_t;
+ typedef iterator_range<counting_iterator_t> result_t;
+ return result_t(counting_iterator_t(first),
+ counting_iterator_t(last));
+ }
- template<class Range>
- inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> >
- counting_range(const Range& rng)
- {
- typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> counting_iterator_t;
- typedef iterator_range<counting_iterator_t> result_t;
- return boost::empty(rng)
- ? result_t()
- : result_t(
+ template<class Range>
+ inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> >
+ counting_range(const Range& rng)
+ {
+ typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> counting_iterator_t;
+ typedef iterator_range<counting_iterator_t> result_t;
+ return boost::empty(rng)
+ ? result_t()
+ : result_t(
counting_iterator_t(*boost::begin(rng)),
counting_iterator_t(*boost::prior(boost::end(rng))));
- }
+ }
- template<class Range>
- inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> >
- counting_range(Range& rng)
- {
- typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> counting_iterator_t;
- typedef iterator_range<counting_iterator_t> result_t;
- return boost::empty(rng)
- ? result_t()
- : result_t(
+ template<class Range>
+ inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> >
+ counting_range(Range& rng)
+ {
+ typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> counting_iterator_t;
+ typedef iterator_range<counting_iterator_t> result_t;
+ return boost::empty(rng)
+ ? result_t()
+ : result_t(
counting_iterator_t(*boost::begin(rng)),
counting_iterator_t(*boost::prior(boost::end(rng))));
- }
+ }
} // namespace boost
#if BOOST_MSVC >= 1400
Modified: trunk/boost/range/detail/demote_iterator_traversal_tag.hpp
==============================================================================
--- trunk/boost/range/detail/demote_iterator_traversal_tag.hpp (original)
+++ trunk/boost/range/detail/demote_iterator_traversal_tag.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -15,8 +15,8 @@
namespace boost
{
- namespace range_detail
- {
+ namespace range_detail
+ {
template<class IteratorTraversalTag1, class IteratorTraversalTag2>
struct demote_iterator_traversal_tag
@@ -26,7 +26,7 @@
#define BOOST_DEMOTE_TRAVERSAL_TAG( Tag1, Tag2, ResultTag ) \
template<> struct demote_iterator_traversal_tag< Tag1 , Tag2 > \
{ \
- typedef ResultTag type; \
+ typedef ResultTag type; \
};
BOOST_DEMOTE_TRAVERSAL_TAG( no_traversal_tag, no_traversal_tag, no_traversal_tag )
@@ -73,7 +73,7 @@
#undef BOOST_DEMOTE_TRAVERSAL_TAG
- } // namespace range_detail
+ } // namespace range_detail
} // namespace boost
#endif // include guard
Modified: trunk/boost/range/join.hpp
==============================================================================
--- trunk/boost/range/join.hpp (original)
+++ trunk/boost/range/join.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -21,46 +21,46 @@
template<class SinglePassRange1, class SinglePassRange2>
iterator_range<range_detail::join_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
- BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
- BOOST_DEDUCED_TYPENAME add_const<
- BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type>
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
+ BOOST_DEDUCED_TYPENAME add_const<
+ BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type>
>
join(const SinglePassRange1& r1, const SinglePassRange2& r2)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
- typedef range_detail::join_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
- BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
- BOOST_DEDUCED_TYPENAME add_const<
- BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type> iterator_t;
-
- return iterator_range<iterator_t>(
- iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
- iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
+ typedef range_detail::join_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
+ BOOST_DEDUCED_TYPENAME add_const<
+ BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type> iterator_t;
+
+ return iterator_range<iterator_t>(
+ iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
+ iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
}
template<class SinglePassRange1, class SinglePassRange2>
iterator_range<range_detail::join_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
- BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
- BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type>
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
+ BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type>
>
join(SinglePassRange1& r1, SinglePassRange2& r2)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
- typedef range_detail::join_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
- BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
- BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type> iterator_t;
-
- return iterator_range<iterator_t>(
- iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
- iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
+ typedef range_detail::join_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
+ BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type> iterator_t;
+
+ return iterator_range<iterator_t>(
+ iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
+ iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
}
} // namespace boost
Modified: trunk/boost/range/numeric.hpp
==============================================================================
--- trunk/boost/range/numeric.hpp (original)
+++ trunk/boost/range/numeric.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -20,7 +20,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
#if defined(_MSC_VER) && _MSC_VER >= 1000
- #pragma once
+ #pragma once
#endif
#ifndef BOOST_RANGE_NUMERIC_HPP
@@ -36,82 +36,82 @@
namespace boost
{
- template< class SinglePassRange, class Value >
- inline Value accumulate( const SinglePassRange& rng, Value init )
- {
+ template< class SinglePassRange, class Value >
+ inline Value accumulate( const SinglePassRange& rng, Value init )
+ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
- return std::accumulate( boost::begin(rng), boost::end(rng), init );
- }
+ return std::accumulate( boost::begin(rng), boost::end(rng), init );
+ }
- template< class SinglePassRange, class Value, class BinaryOperation >
- inline Value accumulate( const SinglePassRange& rng, Value init, BinaryOperation op )
- {
+ template< class SinglePassRange, class Value, class BinaryOperation >
+ inline Value accumulate( const SinglePassRange& rng, Value init, BinaryOperation op )
+ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
- return std::accumulate( boost::begin(rng), boost::end(rng), init, op );
- }
+ return std::accumulate( boost::begin(rng), boost::end(rng), init, op );
+ }
- template< class SinglePassRange1, class SinglePassRange2, class Value >
- inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init )
- {
+ template< class SinglePassRange1, class SinglePassRange2, class Value >
+ inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init )
+ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
- return std::inner_product( boost::begin(rng1), boost::end(rng1),
+ return std::inner_product( boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), init );
- }
+ }
- template< class SinglePassRange1,
+ template< class SinglePassRange1,
class SinglePassRange2,
class Value,
- class BinaryOperation1, class BinaryOperation2 >
- inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
+ class BinaryOperation1, class BinaryOperation2 >
+ inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
Value init,
- BinaryOperation1 op1, BinaryOperation2 op2 )
- {
+ BinaryOperation1 op1, BinaryOperation2 op2 )
+ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
- return std::inner_product( boost::begin(rng1), boost::end(rng1),
+ return std::inner_product( boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), init, op1, op2 );
- }
+ }
- template< class SinglePassRange, class OutputIterator >
- inline OutputIterator partial_sum ( const SinglePassRange& rng,
- OutputIterator result )
- {
- boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
- return std::partial_sum( boost::begin(rng), boost::end(rng), result );
- }
-
- template< class SinglePassRange, class OutputIterator, class BinaryOperation >
- inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result,
- BinaryOperation op )
- {
- boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
- return std::partial_sum( boost::begin(rng), boost::end(rng), result, op );
- }
-
- template< class SinglePassRange, class OutputIterator >
- inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
- OutputIterator result )
- {
- boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
- return std::adjacent_difference( boost::begin(rng), boost::end(rng),
- result );
- }
-
- template< class SinglePassRange, class OutputIterator, class BinaryOperation >
- inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
- OutputIterator result,
- BinaryOperation op )
- {
- boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
- return std::adjacent_difference( boost::begin(rng), boost::end(rng),
- result, op );
- }
-
+ template< class SinglePassRange, class OutputIterator >
+ inline OutputIterator partial_sum ( const SinglePassRange& rng,
+ OutputIterator result )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::partial_sum( boost::begin(rng), boost::end(rng), result );
+ }
+
+ template< class SinglePassRange, class OutputIterator, class BinaryOperation >
+ inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result,
+ BinaryOperation op )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::partial_sum( boost::begin(rng), boost::end(rng), result, op );
+ }
+
+ template< class SinglePassRange, class OutputIterator >
+ inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
+ OutputIterator result )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::adjacent_difference( boost::begin(rng), boost::end(rng),
+ result );
+ }
+
+ template< class SinglePassRange, class OutputIterator, class BinaryOperation >
+ inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
+ OutputIterator result,
+ BinaryOperation op )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::adjacent_difference( boost::begin(rng), boost::end(rng),
+ result, op );
+ }
+
}
#endif
Modified: trunk/boost/range/size_type.hpp
==============================================================================
--- trunk/boost/range/size_type.hpp (original)
+++ trunk/boost/range/size_type.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -68,7 +68,7 @@
template< class T >
struct range_size<const T >
- : detail::range_size<T>
+ : detail::range_size<T>
{ };
} // namespace boost
Modified: trunk/boost/spirit/home/karma/detail/alternative_function.hpp
==============================================================================
--- trunk/boost/spirit/home/karma/detail/alternative_function.hpp (original)
+++ trunk/boost/spirit/home/karma/detail/alternative_function.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -193,4 +193,4 @@
}}}}
-#endif
\ No newline at end of file
+#endif
Modified: trunk/boost/test/impl/unit_test_parameters.ipp
==============================================================================
--- trunk/boost/test/impl/unit_test_parameters.ipp (original)
+++ trunk/boost/test/impl/unit_test_parameters.ipp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -223,9 +223,9 @@
optional<T> val = s_cla_parser.get<optional<T> >( parameter_name );
if( val )
- return *val;
+ return *val;
else
- return optional_value;
+ return optional_value;
}
boost::optional<T> v;
Modified: trunk/boost/test/utils/setcolor.hpp
==============================================================================
--- trunk/boost/test/utils/setcolor.hpp (original)
+++ trunk/boost/test/utils/setcolor.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -103,7 +103,7 @@
~scope_setcolor()
{
if( m_os )
- *m_os << setcolor();
+ *m_os << setcolor();
}
private:
// Data members
Modified: trunk/libs/format/test/format_test3.cpp
==============================================================================
--- trunk/libs/format/test/format_test3.cpp (original)
+++ trunk/libs/format/test/format_test3.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -95,28 +95,28 @@
// bind args, and various arguments counts :
{
- boost::format bf("%1% %4% %1%");
- bf.bind_arg(1, "one") % 2 % "three" ;
- BOOST_CHECK_EQUAL(bf.expected_args(), 4);
- BOOST_CHECK_EQUAL(bf.fed_args(), 2);
- BOOST_CHECK_EQUAL(bf.bound_args(), 1);
- BOOST_CHECK_EQUAL(bf.remaining_args(), 1);
- BOOST_CHECK_EQUAL(bf.cur_arg(), 4);
- bf.clear_binds();
- bf % "one" % 2 % "three" ;
- BOOST_CHECK_EQUAL(bf.expected_args(), 4);
- BOOST_CHECK_EQUAL(bf.fed_args(), 3);
- BOOST_CHECK_EQUAL(bf.bound_args(), 0);
- BOOST_CHECK_EQUAL(bf.remaining_args(), 1);
- BOOST_CHECK_EQUAL(bf.cur_arg(), 4);
+ boost::format bf("%1% %4% %1%");
+ bf.bind_arg(1, "one") % 2 % "three" ;
+ BOOST_CHECK_EQUAL(bf.expected_args(), 4);
+ BOOST_CHECK_EQUAL(bf.fed_args(), 2);
+ BOOST_CHECK_EQUAL(bf.bound_args(), 1);
+ BOOST_CHECK_EQUAL(bf.remaining_args(), 1);
+ BOOST_CHECK_EQUAL(bf.cur_arg(), 4);
+ bf.clear_binds();
+ bf % "one" % 2 % "three" ;
+ BOOST_CHECK_EQUAL(bf.expected_args(), 4);
+ BOOST_CHECK_EQUAL(bf.fed_args(), 3);
+ BOOST_CHECK_EQUAL(bf.bound_args(), 0);
+ BOOST_CHECK_EQUAL(bf.remaining_args(), 1);
+ BOOST_CHECK_EQUAL(bf.cur_arg(), 4);
}
// testcase for bug reported at
// http://listarchives.boost.org/boost-users/2006/05/19723.php
{
- format f("%40t%1%");
- int x = 0;
- f.bind_arg(1, x);
- f.clear();
+ format f("%40t%1%");
+ int x = 0;
+ f.bind_arg(1, x);
+ f.clear();
}
// testcase for bug reported at
Modified: trunk/libs/intrusive/test/generic_assoc_test.hpp
==============================================================================
--- trunk/libs/intrusive/test/generic_assoc_test.hpp (original)
+++ trunk/libs/intrusive/test/generic_assoc_test.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -402,9 +402,9 @@
for(vec_iterator it(--values.end()); true; --it){
testset.push_front(*it);
- if(it == values.begin()){
+ if(it == values.begin()){
break;
- }
+ }
}
BOOST_TEST(testset.size() == values.size());
TEST_INTRUSIVE_SEQUENCE_EXPECTED(values, testset.begin());
Modified: trunk/libs/numeric/ublas/test/sparse_view_test.cpp
==============================================================================
--- trunk/libs/numeric/ublas/test/sparse_view_test.cpp (original)
+++ trunk/libs/numeric/ublas/test/sparse_view_test.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -75,9 +75,9 @@
{
std::cout << ( ublas::make_compressed_matrix_view<ublas::column_major,IB>(4,3,NNZ
- , ublas::c_array_view<const unsigned int>(4,&(IA[0]))
- , ublas::c_array_view<const unsigned int>(6,&(JA[0]))
- , ublas::c_array_view<const double>(6,&(VA[0]))) ) << std::endl;
+ , ublas::c_array_view<const unsigned int>(4,&(IA[0]))
+ , ublas::c_array_view<const unsigned int>(6,&(JA[0]))
+ , ublas::c_array_view<const double>(6,&(VA[0]))) ) << std::endl;
unsigned int * ia = new unsigned int[4]();
unsigned int * ja = new unsigned int[6]();
@@ -94,9 +94,9 @@
, ublas::c_array_view<double> > COMPMATVIEW;
COMPMATVIEW viewA(4,3,NNZ
- , ublas::c_array_view<unsigned int>(4,ia)
- , ublas::c_array_view<unsigned int>(6,ja)
- , ublas::c_array_view<double>(6,va));
+ , ublas::c_array_view<unsigned int>(4,ia)
+ , ublas::c_array_view<unsigned int>(6,ja)
+ , ublas::c_array_view<double>(6,va));
std::cout << viewA << std::endl;
Modified: trunk/libs/numeric/ublas/test/utils.hpp
==============================================================================
--- trunk/libs/numeric/ublas/test/utils.hpp (original)
+++ trunk/libs/numeric/ublas/test/utils.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -14,9 +14,9 @@
#define JOIN_(x,y) x ## y
#ifndef NDEBUG
-# define BOOST_UBLAS_DEBUG_TRACE(x) std::cerr << "[Debug>> " << EXPAND_(x) << std::endl
+# define BOOST_UBLAS_DEBUG_TRACE(x) std::cerr << "[Debug>> " << EXPAND_(x) << std::endl
#else
-# define BOOST_UBLAS_DEBUG_TRACE(x) /**/
+# define BOOST_UBLAS_DEBUG_TRACE(x) /**/
#endif // NDEBUG
#define BOOST_UBLAS_TEST_BEGIN() unsigned int test_fails_(0)
Modified: trunk/libs/pool/test/sys_allocator.hpp
==============================================================================
--- trunk/libs/pool/test/sys_allocator.hpp (original)
+++ trunk/libs/pool/test/sys_allocator.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -97,4 +97,4 @@
{ p->~T(); }
};
-#endif
\ No newline at end of file
+#endif
Modified: trunk/libs/program_options/example/multiple_sources.cpp
==============================================================================
--- trunk/libs/program_options/example/multiple_sources.cpp (original)
+++ trunk/libs/program_options/example/multiple_sources.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -79,7 +79,7 @@
ifstream ifs(config_file.c_str());
if (!ifs)
{
- cout << "can not open config file: " << config_file << "\n";
+ cout << "can not open config file: " << config_file << "\n";
return 0;
}
else
Modified: trunk/libs/python/test/exec.cpp
==============================================================================
--- trunk/libs/python/test/exec.cpp (original)
+++ trunk/libs/python/test/exec.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -61,11 +61,11 @@
// Register the module with the interpreter
if (PyImport_AppendInittab(const_cast<char*>("embedded_hello"),
#if PY_VERSION_HEX >= 0x03000000
- PyInit_embedded_hello
+ PyInit_embedded_hello
#else
- initembedded_hello
+ initembedded_hello
#endif
- ) == -1)
+ ) == -1)
throw std::runtime_error("Failed to add embedded_hello to the interpreter's "
"builtin modules");
// Retrieve the main module
Modified: trunk/libs/range/test/adaptor_test/adjacent_filtered_example.cpp
==============================================================================
--- trunk/libs/range/test/adaptor_test/adjacent_filtered_example.cpp (original)
+++ trunk/libs/range/test/adaptor_test/adjacent_filtered_example.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -55,4 +55,4 @@
test->add( BOOST_TEST_CASE( &adjacent_filtered_example_test ) );
return test;
-}
\ No newline at end of file
+}
Modified: trunk/libs/range/test/adaptor_test/copied_example.cpp
==============================================================================
--- trunk/libs/range/test/adaptor_test/copied_example.cpp (original)
+++ trunk/libs/range/test/adaptor_test/copied_example.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -55,4 +55,4 @@
test->add( BOOST_TEST_CASE( &copied_example_test ) );
return test;
-}
\ No newline at end of file
+}
Modified: trunk/libs/range/test/algorithm_test/find.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/find.cpp (original)
+++ trunk/libs/range/test/algorithm_test/find.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -36,16 +36,16 @@
return boost::find(cont, 3);
}
- template<range_return_value return_type>
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy&, Container& cont)
- {
- return boost::find<return_type>(cont, 3);
- }
- };
+ template<range_return_value return_type>
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy&, Container& cont)
+ {
+ return boost::find<return_type>(cont, 3);
+ }
+ };
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
Modified: trunk/libs/range/test/algorithm_test/find_end.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/find_end.cpp (original)
+++ trunk/libs/range/test/algorithm_test/find_end.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -35,7 +35,7 @@
{
}
- container2_t cont() { return m_cont; }
+ container2_t cont() { return m_cont; }
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
@@ -45,14 +45,14 @@
}
template<range_return_value return_type>
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::find_end<return_type>(cont, policy.cont());
- }
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::find_end<return_type>(cont, policy.cont());
+ }
};
template<class Container>
@@ -77,8 +77,8 @@
{
}
- container2_t& cont() { return m_cont; }
- BinaryPredicate& pred() { return m_pred; }
+ container2_t& cont() { return m_cont; }
+ BinaryPredicate& pred() { return m_pred; }
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
@@ -88,14 +88,14 @@
}
template<range_return_value return_type>
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::find_end<return_type>(cont, policy.cont(), policy.pred());
- }
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::find_end<return_type>(cont, policy.cont(), policy.pred());
+ }
};
template<class Container>
Modified: trunk/libs/range/test/algorithm_test/find_first_of.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/find_first_of.cpp (original)
+++ trunk/libs/range/test/algorithm_test/find_first_of.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -35,7 +35,7 @@
{
}
- container2_t& cont() { return m_cont; }
+ container2_t& cont() { return m_cont; }
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
@@ -45,14 +45,14 @@
}
template<range_return_value return_type>
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::find_first_of<return_type>(cont, policy.cont());
- }
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::find_first_of<return_type>(cont, policy.cont());
+ }
};
template<class Container>
@@ -77,8 +77,8 @@
{
}
- container2_t& cont() { return m_cont; }
- BinaryPredicate& pred() { return m_pred; }
+ container2_t& cont() { return m_cont; }
+ BinaryPredicate& pred() { return m_pred; }
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
@@ -88,14 +88,14 @@
}
template<range_return_value return_type>
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::find_first_of<return_type>(cont, policy.cont(), policy.pred());
- }
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::find_first_of<return_type>(cont, policy.cont(), policy.pred());
+ }
};
template<class Container>
Modified: trunk/libs/range/test/algorithm_test/find_if.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/find_if.cpp (original)
+++ trunk/libs/range/test/algorithm_test/find_if.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -41,15 +41,15 @@
return boost::find_if(cont, m_pred);
}
- template<range_return_value return_type>
- struct test_range
- {
- template<class Container>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(find_if_test_policy& policy, Container& cont)
- {
- return boost::find_if<return_type>(cont, policy.pred());
- }
+ template<range_return_value return_type>
+ struct test_range
+ {
+ template<class Container>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(find_if_test_policy& policy, Container& cont)
+ {
+ return boost::find_if<return_type>(cont, policy.pred());
+ }
};
template<class Container>
@@ -59,7 +59,7 @@
return std::find_if(cont.begin(), cont.end(), m_pred);
}
- UnaryPredicate& pred() { return m_pred; }
+ UnaryPredicate& pred() { return m_pred; }
private:
UnaryPredicate m_pred;
Modified: trunk/libs/range/test/algorithm_test/for_each.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/for_each.cpp (original)
+++ trunk/libs/range/test/algorithm_test/for_each.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -83,4 +83,4 @@
test->add( BOOST_TEST_CASE( &boost::test_for_each ) );
return test;
-}
\ No newline at end of file
+}
Modified: trunk/libs/range/test/algorithm_test/lower_bound.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/lower_bound.cpp (original)
+++ trunk/libs/range/test/algorithm_test/lower_bound.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -36,16 +36,16 @@
return boost::lower_bound(cont, 5);
}
- template<range_return_value return_type>
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy&, Container& cont)
- {
- return boost::lower_bound<return_type>(cont, 5);
- }
- };
+ template<range_return_value return_type>
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy&, Container& cont)
+ {
+ return boost::lower_bound<return_type>(cont, 5);
+ }
+ };
template< class Container >
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
@@ -66,15 +66,15 @@
}
template< range_return_value return_type >
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::lower_bound<return_type>(
- cont, 5, policy.pred());
- }
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::lower_bound<return_type>(
+ cont, 5, policy.pred());
+ }
};
template<class Container>
@@ -85,10 +85,10 @@
cont.begin(), cont.end(), 5, m_pred);
}
- BinaryPredicate& pred() { return m_pred; }
+ BinaryPredicate& pred() { return m_pred; }
- private:
- BinaryPredicate m_pred;
+ private:
+ BinaryPredicate m_pred;
};
template<class Container,
Modified: trunk/libs/range/test/algorithm_test/max_element.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/max_element.cpp (original)
+++ trunk/libs/range/test/algorithm_test/max_element.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -37,14 +37,14 @@
}
template<range_return_value return_type>
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy&, Container& cont)
- {
- return boost::max_element<return_type>(cont);
- }
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy&, Container& cont)
+ {
+ return boost::max_element<return_type>(cont);
+ }
};
template< class Container >
@@ -66,17 +66,17 @@
return boost::max_element(cont, Pred());
}
- Pred pred() const { return Pred(); }
+ Pred pred() const { return Pred(); }
template< range_return_value return_type >
- struct test_range
- {
- template< class Container, class Policy >
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::max_element<return_type>(cont, policy.pred());
- }
+ struct test_range
+ {
+ template< class Container, class Policy >
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::max_element<return_type>(cont, policy.pred());
+ }
};
template< class Container >
Modified: trunk/libs/range/test/algorithm_test/min_element.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/min_element.cpp (original)
+++ trunk/libs/range/test/algorithm_test/min_element.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -37,14 +37,14 @@
}
template< range_return_value return_type >
- struct test_range
- {
- template< class Container, class Policy >
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy&, Container& cont)
- {
- return boost::min_element<return_type>(cont);
- }
+ struct test_range
+ {
+ template< class Container, class Policy >
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy&, Container& cont)
+ {
+ return boost::min_element<return_type>(cont);
+ }
};
template< class Container >
@@ -66,17 +66,17 @@
return boost::min_element(cont, Pred());
}
- Pred pred() const { return Pred(); }
+ Pred pred() const { return Pred(); }
template< range_return_value return_type >
- struct test_range
- {
- template< class Container, class Policy >
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::min_element<return_type>(cont, policy.pred());
- }
+ struct test_range
+ {
+ template< class Container, class Policy >
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::min_element<return_type>(cont, policy.pred());
+ }
};
template< class Container >
Modified: trunk/libs/range/test/algorithm_test/partition.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/partition.cpp (original)
+++ trunk/libs/range/test/algorithm_test/partition.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -44,17 +44,17 @@
return boost::partition(cont, UnaryPredicate());
}
- UnaryPredicate pred() const { return UnaryPredicate(); }
+ UnaryPredicate pred() const { return UnaryPredicate(); }
template< range_return_value return_type >
- struct test_range
- {
- template< class Container, class Policy >
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::partition<return_type>(cont, policy.pred());
- }
+ struct test_range
+ {
+ template< class Container, class Policy >
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::partition<return_type>(cont, policy.pred());
+ }
};
template< class Container >
Modified: trunk/libs/range/test/algorithm_test/stable_partition.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/stable_partition.cpp (original)
+++ trunk/libs/range/test/algorithm_test/stable_partition.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -44,17 +44,17 @@
return boost::stable_partition(cont, UnaryPredicate());
}
- UnaryPredicate pred() const { return UnaryPredicate(); }
+ UnaryPredicate pred() const { return UnaryPredicate(); }
template< range_return_value return_type >
- struct test_range
- {
- template< class Container, class Policy >
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::stable_partition<return_type>(cont, policy.pred());
- }
+ struct test_range
+ {
+ template< class Container, class Policy >
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::stable_partition<return_type>(cont, policy.pred());
+ }
};
template< class Container >
Modified: trunk/libs/range/test/algorithm_test/unique.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/unique.cpp (original)
+++ trunk/libs/range/test/algorithm_test/unique.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -41,14 +41,14 @@
}
template< range_return_value return_type >
- struct test_range
- {
- template< class Container, class Policy >
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy&, Container& cont)
- {
- return boost::unique<return_type>(cont);
- }
+ struct test_range
+ {
+ template< class Container, class Policy >
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy&, Container& cont)
+ {
+ return boost::unique<return_type>(cont);
+ }
};
template< class Container >
@@ -73,17 +73,17 @@
return std::unique(cont.begin(), cont.end(), Pred());
}
- Pred pred() const { return Pred(); }
+ Pred pred() const { return Pred(); }
template< range_return_value return_type >
- struct test_range
- {
- template< class Container, class Policy >
- BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::unique<return_type>(cont, policy.pred());
- }
+ struct test_range
+ {
+ template< class Container, class Policy >
+ BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::unique<return_type>(cont, policy.pred());
+ }
};
template< class Container >
Modified: trunk/libs/range/test/algorithm_test/upper_bound.cpp
==============================================================================
--- trunk/libs/range/test/algorithm_test/upper_bound.cpp (original)
+++ trunk/libs/range/test/algorithm_test/upper_bound.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -35,16 +35,16 @@
return boost::upper_bound(cont, 5);
}
- template<range_return_value result_type>
- struct test_range
- {
- template<class Container, class Policy>
- BOOST_DEDUCED_TYPENAME range_return<Container,result_type>::type
- operator()(Policy&, Container& cont)
- {
- return boost::upper_bound<result_type>(cont, 5);
- }
- };
+ template<range_return_value result_type>
+ struct test_range
+ {
+ template<class Container, class Policy>
+ BOOST_DEDUCED_TYPENAME range_return<Container,result_type>::type
+ operator()(Policy&, Container& cont)
+ {
+ return boost::upper_bound<result_type>(cont, 5);
+ }
+ };
template< class Container >
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
@@ -65,15 +65,15 @@
}
template< range_return_value result_type>
- struct test_range
- {
- template< class Container, class Policy >
- BOOST_DEDUCED_TYPENAME range_return<Container,result_type>::type
- operator()(Policy& policy, Container& cont)
- {
- return boost::upper_bound<result_type>(
- cont, 5, policy.pred());
- }
+ struct test_range
+ {
+ template< class Container, class Policy >
+ BOOST_DEDUCED_TYPENAME range_return<Container,result_type>::type
+ operator()(Policy& policy, Container& cont)
+ {
+ return boost::upper_bound<result_type>(
+ cont, 5, policy.pred());
+ }
};
template<class Container>
@@ -83,11 +83,11 @@
return std::upper_bound(
cont.begin(), cont.end(), 5, BinaryPredicate());
}
-
- BinaryPredicate& pred() { return m_pred; }
-
- private:
- BinaryPredicate m_pred;
+
+ BinaryPredicate& pred() { return m_pred; }
+
+ private:
+ BinaryPredicate m_pred;
};
template<class Container,
Modified: trunk/libs/range/test/counting_range.cpp
==============================================================================
--- trunk/libs/range/test/counting_range.cpp (original)
+++ trunk/libs/range/test/counting_range.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -70,4 +70,4 @@
test->add( BOOST_TEST_CASE( &boost::counting_range_test ) );
return test;
-}
\ No newline at end of file
+}
Modified: trunk/libs/range/test/iterator_range.cpp
==============================================================================
--- trunk/libs/range/test/iterator_range.cpp (original)
+++ trunk/libs/range/test/iterator_range.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -61,7 +61,7 @@
BOOST_CHECK_EQUAL( r2.size(), size( r2 ) );
BOOST_CHECK_EQUAL( std::distance( r.begin(), r.end() ),
- std::distance( boost::begin( r2 ), boost::end( r2 ) ) );
+ std::distance( boost::begin( r2 ), boost::end( r2 ) ) );
std::cout << r << r2;
Modified: trunk/libs/range/test/test_driver/range_return_test_driver.hpp
==============================================================================
--- trunk/libs/range/test/test_driver/range_return_test_driver.hpp (original)
+++ trunk/libs/range/test/test_driver/range_return_test_driver.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -379,25 +379,25 @@
range_result, reference_it);
}
- template< range_return_value result_type, class Container, class TestPolicy >
- struct test_range
- {
- void operator()(Container& cont, TestPolicy policy)
- {
- typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iterator_t;
- typedef BOOST_DEDUCED_TYPENAME range_return<Container, result_type>::type range_return_t;
- typedef BOOST_DEDUCED_TYPENAME TestPolicy::template test_range<result_type> test_range_t;
+ template< range_return_value result_type, class Container, class TestPolicy >
+ struct test_range
+ {
+ void operator()(Container& cont, TestPolicy policy)
+ {
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iterator_t;
+ typedef BOOST_DEDUCED_TYPENAME range_return<Container, result_type>::type range_return_t;
+ typedef BOOST_DEDUCED_TYPENAME TestPolicy::template test_range<result_type> test_range_t;
- Container reference(cont);
- Container test_cont(cont);
+ Container reference(cont);
+ Container test_cont(cont);
- range_return_t range_result = test_range_t()(policy, test_cont);
- iterator_t reference_it = policy.reference(reference);
+ range_return_t range_result = test_range_t()(policy, test_cont);
+ iterator_t reference_it = policy.reference(reference);
- check_results<result_type>::check(test_cont, reference,
+ check_results<result_type>::check(test_cont, reference,
range_result, reference_it);
- }
- };
+ }
+ };
};
}
}
Modified: trunk/libs/spirit/example/scheme/input/sexpr.hpp
==============================================================================
--- trunk/libs/spirit/example/scheme/input/sexpr.hpp (original)
+++ trunk/libs/spirit/example/scheme/input/sexpr.hpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -76,7 +76,7 @@
void operator()(utree& ast, Range const& rng) const
{
int n = get_line(rng.begin());
- BOOST_ASSERT(n <= std::numeric_limits<short>::max());
+ BOOST_ASSERT(n <= (std::numeric_limits<short>::max)());
ast.tag(n);
}
};
Modified: trunk/libs/test/doc/src/examples/example17.cpp
==============================================================================
--- trunk/libs/test/doc/src/examples/example17.cpp (original)
+++ trunk/libs/test/doc/src/examples/example17.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -24,4 +24,4 @@
//____________________________________________________________________________//
-BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
+BOOST_AUTO_TEST_SUITE_END()
Modified: trunk/libs/test/doc/src/examples/example22.cpp
==============================================================================
--- trunk/libs/test/doc/src/examples/example22.cpp (original)
+++ trunk/libs/test/doc/src/examples/example22.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -22,4 +22,4 @@
int j = 2/(i-1);
}
-//____________________________________________________________________________//
\ No newline at end of file
+//____________________________________________________________________________//
Modified: trunk/libs/test/doc/src/examples/example23.cpp
==============================================================================
--- trunk/libs/test/doc/src/examples/example23.cpp (original)
+++ trunk/libs/test/doc/src/examples/example23.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -17,4 +17,4 @@
int j = *p;
}
-//____________________________________________________________________________//
\ No newline at end of file
+//____________________________________________________________________________//
Modified: trunk/tools/regression/test/test-boost-build/missing_dependencies/lib/lib.cpp
==============================================================================
--- trunk/tools/regression/test/test-boost-build/missing_dependencies/lib/lib.cpp (original)
+++ trunk/tools/regression/test/test-boost-build/missing_dependencies/lib/lib.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -1 +1 @@
-#error
\ No newline at end of file
+#error
Modified: trunk/tools/regression/test/test-boost-build/missing_dependencies/test.cpp
==============================================================================
--- trunk/tools/regression/test/test-boost-build/missing_dependencies/test.cpp (original)
+++ trunk/tools/regression/test/test-boost-build/missing_dependencies/test.cpp 2010-04-20 13:54:16 EDT (Tue, 20 Apr 2010)
@@ -1 +1 @@
-int main() { return 0; }
\ No newline at end of file
+int main() { return 0; }