Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r77325 - in trunk: boost/algorithm/cxx11 libs/algorithm/test
From: marshall_at_[hidden]
Date: 2012-03-13 14:53:14


Author: marshall
Date: 2012-03-13 14:53:14 EDT (Tue, 13 Mar 2012)
New Revision: 77325
URL: http://svn.boost.org/trac/boost/changeset/77325

Log:
Renamed file 'ordered.hpp' to 'is_sorted.hpp' because that's what it contains
Added:
   trunk/boost/algorithm/cxx11/is_sorted.hpp
      - copied unchanged from r77322, /trunk/boost/algorithm/cxx11/ordered.hpp
Removed:
   trunk/boost/algorithm/cxx11/ordered.hpp
Text files modified:
   trunk/libs/algorithm/test/ordered_test.cpp | 2 +-
   1 files changed, 1 insertions(+), 1 deletions(-)

Deleted: trunk/boost/algorithm/cxx11/ordered.hpp
==============================================================================
--- trunk/boost/algorithm/cxx11/ordered.hpp 2012-03-13 14:53:14 EDT (Tue, 13 Mar 2012)
+++ (empty file)
@@ -1,291 +0,0 @@
-// Copyright (c) 2010 Nuovation System Designs, LLC
-// Grant Erickson <gerickson_at_[hidden]>
-//
-// Reworked somewhat by Marshall Clow; August 2010
-//
-// 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)
-//
-// See http://www.boost.org/ for latest version.
-//
-
-#ifndef BOOST_ALGORITHM_ORDERED_HPP
-#define BOOST_ALGORITHM_ORDERED_HPP
-
-#include <algorithm>
-#include <functional>
-#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/mpl/identity.hpp>
-
-namespace boost { namespace algorithm {
-
-#if __cplusplus >= 201103L
-// Use the C++11 versions of iota if it is available
-using std::is_sorted_until; // Section 25.4.1.5
-using std::is_sorted; // Section 25.4.1.5
-#else
-/// \fn is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p )
-/// \return the point in the sequence [first, last) where the elements are unordered
-/// (according to the comparison predicate 'p').
-///
-/// \param first The start of the sequence to be tested.
-/// \param last One past the end of the sequence
-/// \param p A binary predicate that returns true if two elements are ordered.
-///
- template <typename ForwardIterator, typename Pred>
- ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p )
- {
- if ( first == last ) return last; // the empty sequence is ordered
- ForwardIterator next = first;
- while ( ++next != last )
- {
- if ( !p ( *first, *next ))
- return next;
- first = next;
- }
- return last;
- }
-
-/// \fn is_sorted_until ( ForwardIterator first, ForwardIterator last )
-/// \return the point in the sequence [first, last) where the elements are unordered
-///
-/// \param first The start of the sequence to be tested.
-/// \param last One past the end of the sequence
-///
- template <typename ForwardIterator>
- ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last )
- {
- typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
- return boost::algorithm::is_sorted_until ( first, last, std::less_equal<value_type>());
- }
-
-
-/// \fn is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
-/// \return whether or not the entire sequence is sorted
-///
-/// \param first The start of the sequence to be tested.
-/// \param last One past the end of the sequence
-/// \param p A binary predicate that returns true if two elements are ordered.
-///
- template <typename ForwardIterator, typename Pred>
- bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
- {
- return boost::algorithm::is_sorted_until (first, last, p) == last;
- }
-
-/// \fn is_sorted ( ForwardIterator first, ForwardIterator last )
-/// \return whether or not the entire sequence is sorted
-///
-/// \param first The start of the sequence to be tested.
-/// \param last One past the end of the sequence
-///
- template <typename ForwardIterator>
- bool is_sorted ( ForwardIterator first, ForwardIterator last )
- {
- return boost::algorithm::is_sorted_until (first, last) == last;
- }
-#endif
-
-///
-/// -- Range based versions of the C++11 functions
-///
-
-/// \fn is_sorted_until ( const R &range, Pred p )
-/// \return the point in the range R where the elements are unordered
-/// (according to the comparison predicate 'p').
-///
-/// \param range The range to be tested.
-/// \param p A binary predicate that returns true if two elements are ordered.
-///
- template <typename R, typename Pred>
- typename boost::lazy_disable_if_c<
- boost::is_same<R, Pred>::value,
- typename boost::range_iterator<const R>
- >::type is_sorted_until ( const R &range, Pred p )
- {
- return boost::algorithm::is_sorted_until ( boost::begin ( range ), boost::end ( range ), p );
- }
-
-
-/// \fn is_sorted_until ( const R &range )
-/// \return the point in the range R where the elements are unordered
-///
-/// \param range The range to be tested.
-///
- template <typename R>
- typename boost::range_iterator<const R>::type is_sorted_until ( const R &range )
- {
- return boost::algorithm::is_sorted_until ( boost::begin ( range ), boost::end ( range ));
- }
-
-namespace detail {
- typedef struct { typedef bool type; } bool_;
-};
-
-/// \fn is_sorted ( const R &range, Pred p )
-/// \return whether or not the entire range R is sorted
-/// (according to the comparison predicate 'p').
-///
-/// \param range The range to be tested.
-/// \param p A binary predicate that returns true if two elements are ordered.
-///
- template <typename R, typename Pred>
- typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, boost::mpl::identity<bool> >::type
- is_sorted ( const R &range, Pred p )
- {
- return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ), p );
- }
-
-
-/// \fn is_sorted ( const R &range )
-/// \return whether or not the entire range R is sorted
-///
-/// \param range The range to be tested.
-///
- template <typename R>
- bool is_sorted ( const R &range )
- {
- return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ));
- }
-
-
-///
-/// -- Range based versions of the C++11 functions
-///
-
-/// \fn is_increasing ( ForwardIterator first, ForwardIterator last )
-/// \return true if the entire sequence is increasing; i.e, each item is greater than or
-/// equal to the previous one.
-///
-/// \param first The start of the sequence to be tested.
-/// \param last One past the end of the sequence
-///
-/// \note This function will return true for sequences that contain items that compare
-/// equal. If that is not what you intended, you should use is_strictly_increasing instead.
- template <typename ForwardIterator>
- bool is_increasing ( ForwardIterator first, ForwardIterator last )
- {
- typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
- return boost::algorithm::is_sorted (first, last, std::less_equal<value_type>());
- }
-
-
-/// \fn is_increasing ( const R &range )
-/// \return true if the entire sequence is increasing; i.e, each item is greater than or
-/// equal to the previous one.
-///
-/// \param range The range to be tested.
-///
-/// \note This function will return true for sequences that contain items that compare
-/// equal. If that is not what you intended, you should use is_strictly_increasing instead.
- template <typename R>
- bool is_increasing ( const R &range )
- {
- return is_increasing ( boost::begin ( range ), boost::end ( range ));
- }
-
-
-
-/// \fn is_decreasing ( ForwardIterator first, ForwardIterator last )
-/// \return true if the entire sequence is decreasing; i.e, each item is less than
-/// or equal to the previous one.
-///
-/// \param first The start of the sequence to be tested.
-/// \param last One past the end of the sequence
-///
-/// \note This function will return true for sequences that contain items that compare
-/// equal. If that is not what you intended, you should use is_strictly_decreasing instead.
- template <typename ForwardIterator>
- bool is_decreasing ( ForwardIterator first, ForwardIterator last )
- {
- typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
- return boost::algorithm::is_sorted (first, last, std::greater_equal<value_type>());
- }
-
-/// \fn is_decreasing ( const R &range )
-/// \return true if the entire sequence is decreasing; i.e, each item is less than
-/// or equal to the previous one.
-///
-/// \param range The range to be tested.
-///
-/// \note This function will return true for sequences that contain items that compare
-/// equal. If that is not what you intended, you should use is_strictly_decreasing instead.
- template <typename R>
- bool is_decreasing ( const R &range )
- {
- return is_decreasing ( boost::begin ( range ), boost::end ( range ));
- }
-
-
-
-/// \fn is_strictly_increasing ( ForwardIterator first, ForwardIterator last )
-/// \return true if the entire sequence is strictly increasing; i.e, each item is greater
-/// than the previous one
-///
-/// \param first The start of the sequence to be tested.
-/// \param last One past the end of the sequence
-///
-/// \note This function will return false for sequences that contain items that compare
-/// equal. If that is not what you intended, you should use is_increasing instead.
- template <typename ForwardIterator>
- bool is_strictly_increasing ( ForwardIterator first, ForwardIterator last )
- {
- typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
- return boost::algorithm::is_sorted (first, last, std::less<value_type>());
- }
-
-/// \fn is_strictly_increasing ( const R &range )
-/// \return true if the entire sequence is strictly increasing; i.e, each item is greater
-/// than the previous one
-///
-/// \param range The range to be tested.
-///
-/// \note This function will return false for sequences that contain items that compare
-/// equal. If that is not what you intended, you should use is_increasing instead.
- template <typename R>
- bool is_strictly_increasing ( const R &range )
- {
- return is_strictly_increasing ( boost::begin ( range ), boost::end ( range ));
- }
-
-
-/// \fn is_strictly_decreasing ( ForwardIterator first, ForwardIterator last )
-/// \return true if the entire sequence is strictly decreasing; i.e, each item is less than
-/// the previous one
-///
-/// \param first The start of the sequence to be tested.
-/// \param last One past the end of the sequence
-///
-/// \note This function will return false for sequences that contain items that compare
-/// equal. If that is not what you intended, you should use is_decreasing instead.
- template <typename ForwardIterator>
- bool is_strictly_decreasing ( ForwardIterator first, ForwardIterator last )
- {
- typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
- return boost::algorithm::is_sorted (first, last, std::greater<value_type>());
- }
-
-/// \fn is_strictly_decreasing ( const R &range )
-/// \return true if the entire sequence is strictly decreasing; i.e, each item is less than
-/// the previous one
-///
-/// \param range The range to be tested.
-///
-/// \note This function will return false for sequences that contain items that compare
-/// equal. If that is not what you intended, you should use is_decreasing instead.
- template <typename R>
- bool is_strictly_decreasing ( const R &range )
- {
- return is_strictly_decreasing ( boost::begin ( range ), boost::end ( range ));
- }
-
-}} // namespace boost
-
-#endif // BOOST_ALGORITHM_ORDERED_HPP

Modified: trunk/libs/algorithm/test/ordered_test.cpp
==============================================================================
--- trunk/libs/algorithm/test/ordered_test.cpp (original)
+++ trunk/libs/algorithm/test/ordered_test.cpp 2012-03-13 14:53:14 EDT (Tue, 13 Mar 2012)
@@ -12,7 +12,7 @@
 #include <algorithm>
 #include <iostream>
 
-#include <boost/algorithm/cxx11/ordered.hpp>
+#include <boost/algorithm/cxx11/is_sorted.hpp>
 #include <boost/test/included/test_exec_monitor.hpp>
 
 using namespace boost;


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk