[Boostheaders-commits] r39 - in pkg/BH/inst/include/boost: . algorithm algorithm/cxx11 algorithm/searching algorithm/searching/detail algorithm/string algorithm/string/detail algorithm/string/std exception exception/detail function function/detail iterator regex regex/config regex/pending regex/v4 test test/included tr1 tr1/tr1
noreply at r-forge.r-project.org
noreply at r-forge.r-project.org
Sat May 4 03:25:47 CEST 2013
Author: edd
Date: 2013-05-04 03:25:45 +0200 (Sat, 04 May 2013)
New Revision: 39
Added:
pkg/BH/inst/include/boost/algorithm/clamp.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/
pkg/BH/inst/include/boost/algorithm/cxx11/all_of.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/any_of.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/copy_if.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/copy_n.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/find_if_not.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/iota.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/is_partitioned.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/is_permutation.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/is_sorted.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/none_of.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/one_of.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/partition_copy.hpp
pkg/BH/inst/include/boost/algorithm/cxx11/partition_point.hpp
pkg/BH/inst/include/boost/algorithm/hex.hpp
pkg/BH/inst/include/boost/algorithm/minmax.hpp
pkg/BH/inst/include/boost/algorithm/minmax_element.hpp
pkg/BH/inst/include/boost/algorithm/searching/
pkg/BH/inst/include/boost/algorithm/searching/boyer_moore.hpp
pkg/BH/inst/include/boost/algorithm/searching/boyer_moore_horspool.hpp
pkg/BH/inst/include/boost/algorithm/searching/detail/
pkg/BH/inst/include/boost/algorithm/searching/detail/bm_traits.hpp
pkg/BH/inst/include/boost/algorithm/searching/detail/debugging.hpp
pkg/BH/inst/include/boost/algorithm/searching/knuth_morris_pratt.hpp
pkg/BH/inst/include/boost/algorithm/string.hpp
pkg/BH/inst/include/boost/algorithm/string/case_conv.hpp
pkg/BH/inst/include/boost/algorithm/string/classification.hpp
pkg/BH/inst/include/boost/algorithm/string/detail/case_conv.hpp
pkg/BH/inst/include/boost/algorithm/string/detail/classification.hpp
pkg/BH/inst/include/boost/algorithm/string/detail/find_iterator.hpp
pkg/BH/inst/include/boost/algorithm/string/detail/finder_regex.hpp
pkg/BH/inst/include/boost/algorithm/string/detail/formatter_regex.hpp
pkg/BH/inst/include/boost/algorithm/string/detail/predicate.hpp
pkg/BH/inst/include/boost/algorithm/string/detail/trim.hpp
pkg/BH/inst/include/boost/algorithm/string/erase.hpp
pkg/BH/inst/include/boost/algorithm/string/find.hpp
pkg/BH/inst/include/boost/algorithm/string/find_iterator.hpp
pkg/BH/inst/include/boost/algorithm/string/iter_find.hpp
pkg/BH/inst/include/boost/algorithm/string/join.hpp
pkg/BH/inst/include/boost/algorithm/string/predicate.hpp
pkg/BH/inst/include/boost/algorithm/string/predicate_facade.hpp
pkg/BH/inst/include/boost/algorithm/string/regex.hpp
pkg/BH/inst/include/boost/algorithm/string/regex_find_format.hpp
pkg/BH/inst/include/boost/algorithm/string/split.hpp
pkg/BH/inst/include/boost/algorithm/string/std/
pkg/BH/inst/include/boost/algorithm/string/std/list_traits.hpp
pkg/BH/inst/include/boost/algorithm/string/std/rope_traits.hpp
pkg/BH/inst/include/boost/algorithm/string/std/slist_traits.hpp
pkg/BH/inst/include/boost/algorithm/string/std/string_traits.hpp
pkg/BH/inst/include/boost/algorithm/string/std_containers_traits.hpp
pkg/BH/inst/include/boost/algorithm/string/trim.hpp
pkg/BH/inst/include/boost/algorithm/string/trim_all.hpp
pkg/BH/inst/include/boost/algorithm/string_regex.hpp
pkg/BH/inst/include/boost/cregex.hpp
pkg/BH/inst/include/boost/exception/all.hpp
pkg/BH/inst/include/boost/exception/detail/clone_current_exception.hpp
pkg/BH/inst/include/boost/exception/detail/exception_ptr.hpp
pkg/BH/inst/include/boost/exception/detail/is_output_streamable.hpp
pkg/BH/inst/include/boost/exception/detail/object_hex_dump.hpp
pkg/BH/inst/include/boost/exception/diagnostic_information.hpp
pkg/BH/inst/include/boost/exception/errinfo_api_function.hpp
pkg/BH/inst/include/boost/exception/errinfo_at_line.hpp
pkg/BH/inst/include/boost/exception/errinfo_errno.hpp
pkg/BH/inst/include/boost/exception/errinfo_file_handle.hpp
pkg/BH/inst/include/boost/exception/errinfo_file_name.hpp
pkg/BH/inst/include/boost/exception/errinfo_file_open_mode.hpp
pkg/BH/inst/include/boost/exception/errinfo_nested_exception.hpp
pkg/BH/inst/include/boost/exception/errinfo_type_info_name.hpp
pkg/BH/inst/include/boost/exception/error_info.hpp
pkg/BH/inst/include/boost/exception/info.hpp
pkg/BH/inst/include/boost/exception/info_tuple.hpp
pkg/BH/inst/include/boost/exception/to_string.hpp
pkg/BH/inst/include/boost/exception/to_string_stub.hpp
pkg/BH/inst/include/boost/exception_ptr.hpp
pkg/BH/inst/include/boost/function.hpp
pkg/BH/inst/include/boost/function/
pkg/BH/inst/include/boost/function/detail/
pkg/BH/inst/include/boost/function/detail/function_iterate.hpp
pkg/BH/inst/include/boost/function/detail/gen_maybe_include.pl
pkg/BH/inst/include/boost/function/detail/maybe_include.hpp
pkg/BH/inst/include/boost/function/detail/prologue.hpp
pkg/BH/inst/include/boost/function/function0.hpp
pkg/BH/inst/include/boost/function/function1.hpp
pkg/BH/inst/include/boost/function/function10.hpp
pkg/BH/inst/include/boost/function/function2.hpp
pkg/BH/inst/include/boost/function/function3.hpp
pkg/BH/inst/include/boost/function/function4.hpp
pkg/BH/inst/include/boost/function/function5.hpp
pkg/BH/inst/include/boost/function/function6.hpp
pkg/BH/inst/include/boost/function/function7.hpp
pkg/BH/inst/include/boost/function/function8.hpp
pkg/BH/inst/include/boost/function/function9.hpp
pkg/BH/inst/include/boost/function/function_base.hpp
pkg/BH/inst/include/boost/function/function_fwd.hpp
pkg/BH/inst/include/boost/function/function_template.hpp
pkg/BH/inst/include/boost/function_equal.hpp
pkg/BH/inst/include/boost/iterator/transform_iterator.hpp
pkg/BH/inst/include/boost/regex.hpp
pkg/BH/inst/include/boost/regex/
pkg/BH/inst/include/boost/regex/config.hpp
pkg/BH/inst/include/boost/regex/config/
pkg/BH/inst/include/boost/regex/config/borland.hpp
pkg/BH/inst/include/boost/regex/config/cwchar.hpp
pkg/BH/inst/include/boost/regex/icu.hpp
pkg/BH/inst/include/boost/regex/pattern_except.hpp
pkg/BH/inst/include/boost/regex/pending/
pkg/BH/inst/include/boost/regex/pending/object_cache.hpp
pkg/BH/inst/include/boost/regex/pending/static_mutex.hpp
pkg/BH/inst/include/boost/regex/pending/unicode_iterator.hpp
pkg/BH/inst/include/boost/regex/regex_traits.hpp
pkg/BH/inst/include/boost/regex/user.hpp
pkg/BH/inst/include/boost/regex/v4/
pkg/BH/inst/include/boost/regex/v4/basic_regex.hpp
pkg/BH/inst/include/boost/regex/v4/basic_regex_creator.hpp
pkg/BH/inst/include/boost/regex/v4/basic_regex_parser.hpp
pkg/BH/inst/include/boost/regex/v4/c_regex_traits.hpp
pkg/BH/inst/include/boost/regex/v4/char_regex_traits.hpp
pkg/BH/inst/include/boost/regex/v4/cpp_regex_traits.hpp
pkg/BH/inst/include/boost/regex/v4/cregex.hpp
pkg/BH/inst/include/boost/regex/v4/error_type.hpp
pkg/BH/inst/include/boost/regex/v4/fileiter.hpp
pkg/BH/inst/include/boost/regex/v4/instances.hpp
pkg/BH/inst/include/boost/regex/v4/iterator_category.hpp
pkg/BH/inst/include/boost/regex/v4/iterator_traits.hpp
pkg/BH/inst/include/boost/regex/v4/match_flags.hpp
pkg/BH/inst/include/boost/regex/v4/match_results.hpp
pkg/BH/inst/include/boost/regex/v4/mem_block_cache.hpp
pkg/BH/inst/include/boost/regex/v4/perl_matcher.hpp
pkg/BH/inst/include/boost/regex/v4/perl_matcher_common.hpp
pkg/BH/inst/include/boost/regex/v4/perl_matcher_non_recursive.hpp
pkg/BH/inst/include/boost/regex/v4/perl_matcher_recursive.hpp
pkg/BH/inst/include/boost/regex/v4/primary_transform.hpp
pkg/BH/inst/include/boost/regex/v4/protected_call.hpp
pkg/BH/inst/include/boost/regex/v4/regbase.hpp
pkg/BH/inst/include/boost/regex/v4/regex.hpp
pkg/BH/inst/include/boost/regex/v4/regex_format.hpp
pkg/BH/inst/include/boost/regex/v4/regex_fwd.hpp
pkg/BH/inst/include/boost/regex/v4/regex_grep.hpp
pkg/BH/inst/include/boost/regex/v4/regex_iterator.hpp
pkg/BH/inst/include/boost/regex/v4/regex_match.hpp
pkg/BH/inst/include/boost/regex/v4/regex_merge.hpp
pkg/BH/inst/include/boost/regex/v4/regex_raw_buffer.hpp
pkg/BH/inst/include/boost/regex/v4/regex_replace.hpp
pkg/BH/inst/include/boost/regex/v4/regex_search.hpp
pkg/BH/inst/include/boost/regex/v4/regex_split.hpp
pkg/BH/inst/include/boost/regex/v4/regex_token_iterator.hpp
pkg/BH/inst/include/boost/regex/v4/regex_traits.hpp
pkg/BH/inst/include/boost/regex/v4/regex_traits_defaults.hpp
pkg/BH/inst/include/boost/regex/v4/regex_workaround.hpp
pkg/BH/inst/include/boost/regex/v4/states.hpp
pkg/BH/inst/include/boost/regex/v4/sub_match.hpp
pkg/BH/inst/include/boost/regex/v4/syntax_type.hpp
pkg/BH/inst/include/boost/regex/v4/u32regex_iterator.hpp
pkg/BH/inst/include/boost/regex/v4/u32regex_token_iterator.hpp
pkg/BH/inst/include/boost/regex/v4/w32_regex_traits.hpp
pkg/BH/inst/include/boost/regex_fwd.hpp
pkg/BH/inst/include/boost/test/included/test_exec_monitor.hpp
pkg/BH/inst/include/boost/test/test_exec_monitor.hpp
pkg/BH/inst/include/boost/tr1/tr1/
pkg/BH/inst/include/boost/tr1/tr1/tuple
pkg/BH/inst/include/boost/tr1/tr1/unordered_map
Log:
also adding boost algorithms/ (in order to build ExactNumCI)
Added: pkg/BH/inst/include/boost/algorithm/clamp.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/clamp.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/clamp.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,175 @@
+/*
+ Copyright (c) Marshall Clow 2008-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+ Revision history:
+ 27 June 2009 mtc First version
+ 23 Oct 2010 mtc Added predicate version
+
+*/
+
+/// \file clamp.hpp
+/// \brief Clamp algorithm
+/// \author Marshall Clow
+///
+/// Suggested by olafvdspek in https://svn.boost.org/trac/boost/ticket/3215
+
+#ifndef BOOST_ALGORITHM_CLAMP_HPP
+#define BOOST_ALGORITHM_CLAMP_HPP
+
+#include <functional> // For std::less
+#include <iterator> // For std::iterator_traits
+#include <cassert>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/mpl/identity.hpp> // for identity
+#include <boost/utility/enable_if.hpp> // for boost::disable_if
+
+namespace boost { namespace algorithm {
+
+/// \fn clamp ( T const& val,
+/// typename boost::mpl::identity<T>::type const& lo,
+/// typename boost::mpl::identity<T>::type const& hi, Pred p )
+/// \return the value "val" brought into the range [ lo, hi ]
+/// using the comparison predicate p.
+/// If p ( val, lo ) return lo.
+/// If p ( hi, val ) return hi.
+/// Otherwise, return the original value.
+///
+/// \param val The value to be clamped
+/// \param lo The lower bound of the range to be clamped to
+/// \param hi The upper bound of the range to be clamped to
+/// \param p A predicate to use to compare the values.
+/// p ( a, b ) returns a boolean.
+///
+ template<typename T, typename Pred>
+ T const & clamp ( T const& val,
+ typename boost::mpl::identity<T>::type const & lo,
+ typename boost::mpl::identity<T>::type const & hi, Pred p )
+ {
+// assert ( !p ( hi, lo )); // Can't assert p ( lo, hi ) b/c they might be equal
+ return p ( val, lo ) ? lo : p ( hi, val ) ? hi : val;
+ }
+
+
+/// \fn clamp ( T const& val,
+/// typename boost::mpl::identity<T>::type const& lo,
+/// typename boost::mpl::identity<T>::type const& hi )
+/// \return the value "val" brought into the range [ lo, hi ].
+/// If the value is less than lo, return lo.
+/// If the value is greater than "hi", return hi.
+/// Otherwise, return the original value.
+///
+/// \param val The value to be clamped
+/// \param lo The lower bound of the range to be clamped to
+/// \param hi The upper bound of the range to be clamped to
+///
+ template<typename T>
+ T const& clamp ( const T& val,
+ typename boost::mpl::identity<T>::type const & lo,
+ typename boost::mpl::identity<T>::type const & hi )
+ {
+ return (clamp) ( val, lo, hi, std::less<T>());
+ }
+
+/// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+/// std::iterator_traits<InputIterator>::value_type lo,
+/// std::iterator_traits<InputIterator>::value_type hi )
+/// \return clamp the sequence of values [first, last) into [ lo, hi ]
+///
+/// \param first The start of the range of values
+/// \param last One past the end of the range of input values
+/// \param out An output iterator to write the clamped values into
+/// \param lo The lower bound of the range to be clamped to
+/// \param hi The upper bound of the range to be clamped to
+///
+ template<typename InputIterator, typename OutputIterator>
+ OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+ typename std::iterator_traits<InputIterator>::value_type lo,
+ typename std::iterator_traits<InputIterator>::value_type hi )
+ {
+ // this could also be written with bind and std::transform
+ while ( first != last )
+ *out++ = clamp ( *first++, lo, hi );
+ return out;
+ }
+
+/// \fn clamp_range ( const Range &r, OutputIterator out,
+/// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo,
+/// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi )
+/// \return clamp the sequence of values [first, last) into [ lo, hi ]
+///
+/// \param r The range of values to be clamped
+/// \param out An output iterator to write the clamped values into
+/// \param lo The lower bound of the range to be clamped to
+/// \param hi The upper bound of the range to be clamped to
+///
+ template<typename Range, typename OutputIterator>
+ typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
+ clamp_range ( const Range &r, OutputIterator out,
+ typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo,
+ typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi )
+ {
+ return clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi );
+ }
+
+
+/// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+/// std::iterator_traits<InputIterator>::value_type lo,
+/// std::iterator_traits<InputIterator>::value_type hi, Pred p )
+/// \return clamp the sequence of values [first, last) into [ lo, hi ]
+/// using the comparison predicate p.
+///
+/// \param first The start of the range of values
+/// \param last One past the end of the range of input values
+/// \param out An output iterator to write the clamped values into
+/// \param lo The lower bound of the range to be clamped to
+/// \param hi The upper bound of the range to be clamped to
+/// \param p A predicate to use to compare the values.
+/// p ( a, b ) returns a boolean.
+
+///
+ template<typename InputIterator, typename OutputIterator, typename Pred>
+ OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+ typename std::iterator_traits<InputIterator>::value_type lo,
+ typename std::iterator_traits<InputIterator>::value_type hi, Pred p )
+ {
+ // this could also be written with bind and std::transform
+ while ( first != last )
+ *out++ = clamp ( *first++, lo, hi, p );
+ return out;
+ }
+
+/// \fn clamp_range ( const Range &r, OutputIterator out,
+/// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo,
+/// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi,
+/// Pred p )
+/// \return clamp the sequence of values [first, last) into [ lo, hi ]
+/// using the comparison predicate p.
+///
+/// \param r The range of values to be clamped
+/// \param out An output iterator to write the clamped values into
+/// \param lo The lower bound of the range to be clamped to
+/// \param hi The upper bound of the range to be clamped to
+/// \param p A predicate to use to compare the values.
+/// p ( a, b ) returns a boolean.
+//
+// Disable this template if the first two parameters are the same type;
+// In that case, the user will get the two iterator version.
+ template<typename Range, typename OutputIterator, typename Pred>
+ typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
+ clamp_range ( const Range &r, OutputIterator out,
+ typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo,
+ typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi,
+ Pred p )
+ {
+ return clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p );
+ }
+
+
+}}
+
+#endif // BOOST_ALGORITHM_CLAMP_HPP
Added: pkg/BH/inst/include/boost/algorithm/cxx11/all_of.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/cxx11/all_of.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/cxx11/all_of.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,91 @@
+/*
+ Copyright (c) Marshall Clow 2008-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file all_of.hpp
+/// \brief Test ranges to see if all elements match a value or predicate.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_ALL_OF_HPP
+#define BOOST_ALGORITHM_ALL_OF_HPP
+
+#include <algorithm> // for std::all_of, if available
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost { namespace algorithm {
+
+#if __cplusplus >= 201103L
+// Use the C++11 versions of all_of if it is available
+using std::all_of; // Section 25.2.1
+#else
+/// \fn all_of ( InputIterator first, InputIterator last, Predicate p )
+/// \return true if all elements in [first, last) satisfy the predicate 'p'
+/// \note returns true on an empty range
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param p A predicate for testing the elements of the sequence
+///
+/// \note This function is part of the C++2011 standard library.
+/// We will use the standard one if it is available,
+/// otherwise we have our own implementation.
+template<typename InputIterator, typename Predicate>
+bool all_of ( InputIterator first, InputIterator last, Predicate p )
+{
+ for ( ; first != last; ++first )
+ if ( !p(*first))
+ return false;
+ return true;
+}
+#endif
+
+/// \fn all_of ( const Range &r, Predicate p )
+/// \return true if all elements in the range satisfy the predicate 'p'
+/// \note returns true on an empty range
+///
+/// \param r The input range
+/// \param p A predicate for testing the elements of the range
+///
+template<typename Range, typename Predicate>
+bool all_of ( const Range &r, Predicate p )
+{
+ return boost::algorithm::all_of ( boost::begin (r), boost::end (r), p );
+}
+
+/// \fn all_of_equal ( InputIterator first, InputIterator last, const T &val )
+/// \return true if all elements in [first, last) are equal to 'val'
+/// \note returns true on an empty range
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param val A value to compare against
+///
+template<typename InputIterator, typename T>
+bool all_of_equal ( InputIterator first, InputIterator last, const T &val )
+{
+ for ( ; first != last; ++first )
+ if ( val != *first )
+ return false;
+ return true;
+}
+
+/// \fn all_of_equal ( const Range &r, const T &val )
+/// \return true if all elements in the range are equal to 'val'
+/// \note returns true on an empty range
+///
+/// \param r The input range
+/// \param val A value to compare against
+///
+template<typename Range, typename T>
+bool all_of_equal ( const Range &r, const T &val )
+{
+ return boost::algorithm::all_of_equal ( boost::begin (r), boost::end (r), val );
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_ALL_OF_HPP
Added: pkg/BH/inst/include/boost/algorithm/cxx11/any_of.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/cxx11/any_of.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/cxx11/any_of.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,90 @@
+/*
+ Copyright (c) Marshall Clow 2008-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+ For more information, see http://www.boost.org
+*/
+
+/// \file
+/// \brief Test ranges to see if any elements match a value or predicate.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_ANY_OF_HPP
+#define BOOST_ALGORITHM_ANY_OF_HPP
+
+#include <algorithm> // for std::any_of, if available
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost { namespace algorithm {
+
+// Use the C++11 versions of any_of if it is available
+#if __cplusplus >= 201103L
+using std::any_of; // Section 25.2.2
+#else
+/// \fn any_of ( InputIterator first, InputIterator last, Predicate p )
+/// \return true if any of the elements in [first, last) satisfy the predicate
+/// \note returns false on an empty range
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param p A predicate for testing the elements of the sequence
+///
+template<typename InputIterator, typename Predicate>
+bool any_of ( InputIterator first, InputIterator last, Predicate p )
+{
+ for ( ; first != last; ++first )
+ if ( p(*first))
+ return true;
+ return false;
+}
+#endif
+
+/// \fn any_of ( const Range &r, Predicate p )
+/// \return true if any elements in the range satisfy the predicate 'p'
+/// \note returns false on an empty range
+///
+/// \param r The input range
+/// \param p A predicate for testing the elements of the range
+///
+template<typename Range, typename Predicate>
+bool any_of ( const Range &r, Predicate p )
+{
+ return boost::algorithm::any_of (boost::begin (r), boost::end (r), p);
+}
+
+/// \fn any_of_equal ( InputIterator first, InputIterator last, const V &val )
+/// \return true if any of the elements in [first, last) are equal to 'val'
+/// \note returns false on an empty range
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param val A value to compare against
+///
+template<typename InputIterator, typename V>
+bool any_of_equal ( InputIterator first, InputIterator last, const V &val )
+{
+ for ( ; first != last; ++first )
+ if ( val == *first )
+ return true;
+ return false;
+}
+
+/// \fn any_of_equal ( const Range &r, const V &val )
+/// \return true if any of the elements in the range are equal to 'val'
+/// \note returns false on an empty range
+///
+/// \param r The input range
+/// \param val A value to compare against
+///
+template<typename Range, typename V>
+bool any_of_equal ( const Range &r, const V &val )
+{
+ return boost::algorithm::any_of_equal (boost::begin (r), boost::end (r), val);
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_ANY_OF_HPP
Added: pkg/BH/inst/include/boost/algorithm/cxx11/copy_if.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/cxx11/copy_if.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/cxx11/copy_if.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,133 @@
+/*
+ Copyright (c) Marshall Clow 2008-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file copy_if.hpp
+/// \brief Copy a subset of a sequence to a new sequence
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_COPY_IF_HPP
+#define BOOST_ALGORITHM_COPY_IF_HPP
+
+#include <algorithm> // for std::copy_if, if available
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost { namespace algorithm {
+
+#if __cplusplus >= 201103L
+// Use the C++11 versions of copy_if if it is available
+using std::copy_if; // Section 25.3.1
+#else
+/// \fn copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
+/// \brief Copies all the elements from the input range that satisfy the
+/// predicate to the output range.
+/// \return The updated output iterator
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param result An output iterator to write the results into
+/// \param p A predicate for testing the elements of the range
+/// \note This function is part of the C++2011 standard library.
+/// We will use the standard one if it is available,
+/// otherwise we have our own implementation.
+template<typename InputIterator, typename OutputIterator, typename Predicate>
+OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
+{
+ for ( ; first != last; ++first )
+ if (p(*first))
+ *result++ = first;
+ return result;
+}
+#endif
+
+/// \fn copy_if ( const Range &r, OutputIterator result, Predicate p )
+/// \brief Copies all the elements from the input range that satisfy the
+/// predicate to the output range.
+/// \return The updated output iterator
+///
+/// \param r The input range
+/// \param result An output iterator to write the results into
+/// \param p A predicate for testing the elements of the range
+///
+template<typename Range, typename OutputIterator, typename Predicate>
+OutputIterator copy_if ( const Range &r, OutputIterator result, Predicate p )
+{
+ return boost::algorithm::copy_if (boost::begin (r), boost::end(r), result, p);
+}
+
+
+/// \fn copy_while ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
+/// \brief Copies all the elements at the start of the input range that
+/// satisfy the predicate to the output range.
+/// \return The updated output iterator
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param result An output iterator to write the results into
+/// \param p A predicate for testing the elements of the range
+///
+template<typename InputIterator, typename OutputIterator, typename Predicate>
+OutputIterator copy_while ( InputIterator first, InputIterator last,
+ OutputIterator result, Predicate p )
+{
+ for ( ; first != last && p(*first); ++first )
+ *result++ = first;
+ return result;
+}
+
+/// \fn copy_while ( const Range &r, OutputIterator result, Predicate p )
+/// \brief Copies all the elements at the start of the input range that
+/// satisfy the predicate to the output range.
+/// \return The updated output iterator
+///
+/// \param r The input range
+/// \param result An output iterator to write the results into
+/// \param p A predicate for testing the elements of the range
+///
+template<typename Range, typename OutputIterator, typename Predicate>
+OutputIterator copy_while ( const Range &r, OutputIterator result, Predicate p )
+{
+ return boost::algorithm::copy_while (boost::begin (r), boost::end(r), result, p);
+}
+
+
+/// \fn copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
+/// \brief Copies all the elements at the start of the input range that do not
+/// satisfy the predicate to the output range.
+/// \return The updated output iterator
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param result An output iterator to write the results into
+/// \param p A predicate for testing the elements of the range
+///
+template<typename InputIterator, typename OutputIterator, typename Predicate>
+OutputIterator copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
+{
+ for ( ; first != last && !p(*first); ++first )
+ *result++ = first;
+ return result;
+}
+
+/// \fn copy_until ( const Range &r, OutputIterator result, Predicate p )
+/// \brief Copies all the elements at the start of the input range that do not
+/// satisfy the predicate to the output range.
+/// \return The updated output iterator
+///
+/// \param r The input range
+/// \param result An output iterator to write the results into
+/// \param p A predicate for testing the elements of the range
+///
+template<typename Range, typename OutputIterator, typename Predicate>
+OutputIterator copy_until ( const Range &r, OutputIterator result, Predicate p )
+{
+ return boost::algorithm::copy_until (boost::begin (r), boost::end(r), result, p);
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_COPY_IF_HPP
Added: pkg/BH/inst/include/boost/algorithm/cxx11/copy_n.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/cxx11/copy_n.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/cxx11/copy_n.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,44 @@
+/*
+ Copyright (c) Marshall Clow 2011-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file copy_n.hpp
+/// \brief Copy n items from one sequence to another
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_COPY_N_HPP
+#define BOOST_ALGORITHM_COPY_N_HPP
+
+#include <algorithm> // for std::copy_n, if available
+
+namespace boost { namespace algorithm {
+
+#if __cplusplus >= 201103L
+// Use the C++11 versions of copy_n if it is available
+using std::copy_n; // Section 25.3.1
+#else
+/// \fn copy_n ( InputIterator first, Size n, OutputIterator result )
+/// \brief Copies exactly n (n > 0) elements from the range starting at first to
+/// the range starting at result.
+/// \return The updated output iterator
+///
+/// \param first The start of the input sequence
+/// \param n The number of elements to copy
+/// \param result An output iterator to write the results into
+/// \note This function is part of the C++2011 standard library.
+/// We will use the standard one if it is available,
+/// otherwise we have our own implementation.
+template <typename InputIterator, typename Size, typename OutputIterator>
+OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result )
+{
+ for ( ; n > 0; --n, ++first, ++result )
+ *result = *first;
+ return result;
+}
+#endif
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_COPY_IF_HPP
Added: pkg/BH/inst/include/boost/algorithm/cxx11/find_if_not.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/cxx11/find_if_not.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/cxx11/find_if_not.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,60 @@
+/*
+ Copyright (c) Marshall Clow 2011-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file find_if_not.hpp
+/// \brief Find the first element in a sequence that does not satisfy a predicate.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP
+#define BOOST_ALGORITHM_FIND_IF_NOT_HPP
+
+#include <algorithm> // for std::find_if_not, if it exists
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost { namespace algorithm {
+
+#if __cplusplus >= 201103L
+// Use the C++11 versions of find_if_not if it is available
+using std::find_if_not; // Section 25.2.5
+#else
+/// \fn find_if_not(InputIterator first, InputIterator last, Predicate p)
+/// \brief Finds the first element in the sequence that does not satisfy the predicate.
+/// \return The iterator pointing to the desired element.
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param p A predicate for testing the elements of the range
+/// \note This function is part of the C++2011 standard library.
+/// We will use the standard one if it is available,
+/// otherwise we have our own implementation.
+template<typename InputIterator, typename Predicate>
+InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p )
+{
+ for ( ; first != last; ++first )
+ if ( !p(*first))
+ break;
+ return first;
+}
+#endif
+
+/// \fn find_if_not ( const Range &r, Predicate p )
+/// \brief Finds the first element in the sequence that does not satisfy the predicate.
+/// \return The iterator pointing to the desired element.
+///
+/// \param r The input range
+/// \param p A predicate for testing the elements of the range
+///
+template<typename Range, typename Predicate>
+typename boost::range_iterator<const Range>::type find_if_not ( const Range &r, Predicate p )
+{
+ return boost::algorithm::find_if_not (boost::begin (r), boost::end(r), p);
+}
+
+}}
+#endif // BOOST_ALGORITHM_FIND_IF_NOT_HPP
Added: pkg/BH/inst/include/boost/algorithm/cxx11/iota.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/cxx11/iota.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/cxx11/iota.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,74 @@
+/*
+ Copyright (c) Marshall Clow 2008-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file iota.hpp
+/// \brief Generate an increasing series
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_IOTA_HPP
+#define BOOST_ALGORITHM_IOTA_HPP
+
+#include <numeric>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost { namespace algorithm {
+
+#if __cplusplus >= 201103L
+// Use the C++11 versions of iota if it is available
+using std::iota; // Section 26.7.6
+#else
+/// \fn iota ( ForwardIterator first, ForwardIterator last, T value )
+/// \brief Generates an increasing sequence of values, and stores them in [first, last)
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param value The initial value of the sequence to be generated
+/// \note This function is part of the C++2011 standard library.
+/// We will use the standard one if it is available,
+/// otherwise we have our own implementation.
+template <typename ForwardIterator, typename T>
+void iota ( ForwardIterator first, ForwardIterator last, T value )
+{
+ for ( ; first != last; ++first, ++value )
+ *first = value;
+}
+#endif
+
+/// \fn iota ( Range &r, T value )
+/// \brief Generates an increasing sequence of values, and stores them in the input Range.
+///
+/// \param r The input range
+/// \param value The initial value of the sequence to be generated
+///
+template <typename Range, typename T>
+void iota ( Range &r, T value )
+{
+ boost::algorithm::iota (boost::begin(r), boost::end(r), value);
+}
+
+
+/// \fn iota_n ( OutputIterator out, T value, std::size_t n )
+/// \brief Generates an increasing sequence of values, and stores them in the input Range.
+///
+/// \param out An output iterator to write the results into
+/// \param value The initial value of the sequence to be generated
+/// \param n The number of items to write
+///
+template <typename OutputIterator, typename T>
+OutputIterator iota_n ( OutputIterator out, T value, std::size_t n )
+{
+ while ( n-- > 0 )
+ *out++ = value++;
+
+ return out;
+}
+
+}}
+
+#endif // BOOST_ALGORITHM_IOTA_HPP
Added: pkg/BH/inst/include/boost/algorithm/cxx11/is_partitioned.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/cxx11/is_partitioned.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/cxx11/is_partitioned.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,65 @@
+/*
+ Copyright (c) Marshall Clow 2011-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file is_partitioned.hpp
+/// \brief Tell if a sequence is partitioned
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
+#define BOOST_ALGORITHM_IS_PARTITIONED_HPP
+
+#include <algorithm> // for std::is_partitioned, if available
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost { namespace algorithm {
+
+#if __cplusplus >= 201103L
+// Use the C++11 versions of is_partitioned if it is available
+using std::is_partitioned; // Section 25.3.13
+#else
+/// \fn is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
+/// \brief Tests to see if a sequence is partititioned according to a predicate
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param p The predicicate to test the values with
+/// \note This function is part of the C++2011 standard library.
+/// We will use the standard one if it is available,
+/// otherwise we have our own implementation.
+template <typename InputIterator, typename UnaryPredicate>
+bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
+{
+// Run through the part that satisfy the predicate
+ for ( ; first != last; ++first )
+ if ( !p (*first))
+ break;
+// Now the part that does not satisfy the predicate
+ for ( ; first != last; ++first )
+ if ( p (*first))
+ return false;
+ return true;
+}
+#endif
+
+/// \fn is_partitioned ( const Range &r, UnaryPredicate p )
+/// \brief Generates an increasing sequence of values, and stores them in the input Range.
+///
+/// \param r The input range
+/// \param p The predicicate to test the values with
+///
+template <typename Range, typename UnaryPredicate>
+bool is_partitioned ( const Range &r, UnaryPredicate p )
+{
+ return boost::algorithm::is_partitioned (boost::begin(r), boost::end(r), p);
+}
+
+
+}}
+
+#endif // BOOST_ALGORITHM_IS_PARTITIONED_HPP
Added: pkg/BH/inst/include/boost/algorithm/cxx11/is_permutation.hpp
===================================================================
--- pkg/BH/inst/include/boost/algorithm/cxx11/is_permutation.hpp (rev 0)
+++ pkg/BH/inst/include/boost/algorithm/cxx11/is_permutation.hpp 2013-05-04 01:25:45 UTC (rev 39)
@@ -0,0 +1,139 @@
+/*
+ Copyright (c) Marshall Clow 2011-2012.
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+/// \file is_permutation.hpp
+/// \brief Is a sequence a permutation of another sequence
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_IS_PERMUTATION_HPP
+#define BOOST_ALGORITHM_IS_PERMUTATION_HPP
+
+#include <algorithm> // for std::less, tie, mismatch and is_permutation (if available)
+#include <utility> // for std::make_pair
+#include <functional> // for std::equal_to
+#include <iterator>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/tr1/tr1/tuple> // for tie
+
+namespace boost { namespace algorithm {
+
+#if __cplusplus >= 201103L
+// Use the C++11 versions of is_permutation if it is available
+using std::is_permutation; // Section 25.2.12
+#else
+/// \cond DOXYGEN_HIDE
+namespace detail {
+ template <typename Predicate, typename Iterator>
+ struct value_predicate {
+ value_predicate ( Predicate p, Iterator it ) : p_ ( p ), it_ ( it ) {}
+
+ template <typename T1>
+ bool operator () ( const T1 &t1 ) const { return p_ ( *it_, t1 ); }
+ private:
+ Predicate &p_;
+ Iterator it_;
+ };
+}
+/// \endcond
+
+
+/// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2, BinaryPredicate p )
+/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
+///
+/// \param first The start of the input sequence
+/// \param last One past the end of the input sequence
+/// \param first2 The start of the second sequence
+/// \param p The predicate to compare elements with
+///
+/// \note This function is part of the C++2011 standard library.
+/// We will use the standard one if it is available,
+/// otherwise we have our own implementation.
+template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
+bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
+ ForwardIterator2 first2, BinaryPredicate p )
+{
+// Skip the common prefix (if any)
+// std::tie (first1, first2) = std::mismatch (first1, last1, first2, p);
+ std::pair<ForwardIterator1, ForwardIterator2> eq = std::mismatch (first1, last1, first2, p);
+ first1 = eq.first;
+ first2 = eq.second;
+ if ( first1 != last1 ) {
+ // Create last2
+ ForwardIterator2 last2 = first2;
+ std::advance ( last2, std::distance (first1, last1));
+
+ // for each unique value in the sequence [first1,last1), count how many times
+ // it occurs, and make sure it occurs the same number of times in [first2, last2)
+ for ( ForwardIterator1 iter = first1; iter != last1; ++iter ) {
[TRUNCATED]
To get the complete diff run:
svnlook diff /svnroot/boostheaders -r 39
More information about the Boostheaders-commits
mailing list