Changeset 63904


Ignore:
Timestamp:
Jul 12, 2010, 12:14:07 AM (8 years ago)
Author:
Neil Groves
Message:

[boost][range] - Improved handling of temporary ranges in range algorithms.

Location:
trunk/libs/range/test
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/libs/range/test/adaptor_test/uniqued.cpp

    r60897 r63904  
    1616#include <boost/assign.hpp>
    1717#include <boost/range/algorithm_ext.hpp>
     18#include <boost/range/sub_range.hpp>
    1819
    1920#include <algorithm>
     
    2223#include <vector>
    2324
     25#include <functional>
    2426namespace boost
    2527{
     28    namespace range3
     29    {
     30        namespace concept
     31        {
     32            template<class Range>
     33            class PopFrontSubRange
     34            {
     35            public:
     36                void constraints()
     37                {
     38                    Range copied_range(*m_range);
     39                    BOOST_DEDUCED_TYPENAME range_value<Range>::type v = copied_range.front();
     40                    copied_range.pop_front();
     41                }
     42            private:
     43                Range* m_range;
     44            };
     45
     46            template<class Range>
     47            class PopBackSubRange
     48            {
     49            public:
     50                void constraints()
     51                {
     52                    Range copied_range(*m_range);
     53                    BOOST_DEDUCED_TYPENAME range_value<Range>::type v = copied_range.back();
     54                    copied_range.pop_back();
     55                }
     56            private:
     57                Range* m_range;
     58            };
     59        } // namespace concept
     60        namespace adaptor
     61        {
     62            template<class Range, class Pred>
     63            class adjacent_filter_adaptor
     64                : private boost::sub_range<Range>
     65                , private Pred
     66            {
     67            public:
     68                typedef boost::sub_range<Range> range_t;
     69                typedef Pred pred_t;
     70                typedef typename range_t::value_type value_type;
     71                using range_t::reference;
     72                using range_t::const_reference;
     73                using range_t::empty;
     74                using range_t::front;
     75                using range_t::back;
     76
     77                adjacent_filter_adaptor(Range& rng, Pred pred)
     78                : range_t(rng)
     79                , pred_t(pred)
     80                {
     81                }
     82
     83                void pop_front()
     84                {
     85                    BOOST_ASSERT( !empty() );
     86                    const value_type& old_front = front();
     87                    range_t::pop_front();
     88                    while (!empty() && !pred_t::operator()(front(), old_front))
     89                        range_t::pop_front();
     90                }
     91
     92                void pop_back()
     93                {
     94                    BOOST_ASSERT( !empty() );
     95                    const value_type& old_back = back();
     96                    range_t::pop_back();
     97                    while (!empty() && !pred_t::operator()(old_back, back()))
     98                        range_t::pop_back();
     99                }
     100            };
     101
     102            template<class Range>
     103            class unique_adaptor
     104                : public adjacent_filter_adaptor<Range, std::not_equal_to< typename range_value<Range>::type > >
     105            {
     106                typedef adjacent_filter_adaptor<Range, std::not_equal_to< typename range_value<Range>::type > > base_t;
     107            public:
     108                typedef std::not_equal_to< typename range_value<Range>::type > pred_t;
     109                explicit unique_adaptor(Range& rng) : base_t(rng, pred_t()) {}
     110            };
     111        }
     112    }
     113
    26114    namespace
    27115    {
    28116        template< class Container >
     117        void new_uniqued_adaptor_test(Container& c)
     118        {
     119            std::vector<int> test_result1;
     120            boost::range3::adaptor::unique_adaptor<Container> rng(c);
     121            while (!rng.empty())
     122            {
     123                test_result1.push_back(rng.front());
     124                rng.pop_front();
     125            }
     126
     127            std::vector<int> test_result2;
     128            boost::push_back(test_result2, adaptors::unique(c));
     129
     130            BOOST_CHECK_EQUAL_COLLECTIONS(
     131                test_result1.begin(), test_result1.end(),
     132                test_result2.begin(), test_result2.end()
     133                );
     134        }
     135
     136        template< class Container >
    29137        void uniqued_test_impl( Container& c )
    30138        {
     139            new_uniqued_adaptor_test(c);
     140
    31141            using namespace boost::adaptors;
    32142
  • trunk/libs/range/test/string.cpp

    r45124 r63904  
    1818#endif
    1919
     20#include <boost/array.hpp>
    2021#include <boost/range/as_array.hpp>
    2122#include <boost/range/as_literal.hpp>
     
    3031#include <algorithm>
    3132
     33namespace
     34{
     35    template< class CharT, std::size_t Length >
     36    class test_string
     37    {
     38    public:
     39        typedef CharT value_type;
     40        typedef value_type* pointer;
     41        typedef const value_type* const_pointer;
     42        typedef std::size_t size_type;
     43        typedef value_type array_t[Length];
     44        typedef const value_type const_array_t[Length];
     45       
     46        explicit test_string(const CharT literal_sz[])
     47        {
     48            std::copy(literal_sz, literal_sz + Length, m_buffer.data());
     49            m_buffer[Length] = value_type();
     50        }
     51
     52        const_pointer const_sz() const { return m_buffer.data(); }
     53        pointer mutable_sz() { return m_buffer.data(); }
     54
     55    private:
     56        typedef boost::array<value_type, Length + 1> buffer_t;
     57        buffer_t m_buffer;
     58    };
     59}
     60
    3261template< class T >
    3362inline BOOST_DEDUCED_TYPENAME boost::range_iterator<T>::type
     
    106135    typedef char*                  char_iterator_t;
    107136    typedef char                   char_array_t[10];
    108     const char*      char_s            = "a string";
    109     char             my_string[]       = "another string";
     137   
     138    test_string<char, 8> a_string("a string");
     139    test_string<char, 14> another_string("another string");
     140
     141    const char*      char_s = a_string.const_sz();
     142    char             my_string[] = "another_string";
    110143    const char       my_const_string[] = "another string";
    111     const unsigned   my_string_length  = 14;
    112     char*            char_s2           = "a string";
     144    const unsigned   my_string_length = 14;
     145    char*            char_s2 = a_string.mutable_sz();
    113146   
    114147    BOOST_STATIC_ASSERT(( is_same<  range_value<char_iterator_t>::type,
     
    182215   
    183216#ifndef BOOST_NO_STD_WSTRING
    184     typedef wchar_t*               wchar_iterator_t;         
    185     const wchar_t*  char_ws      = L"a wide string";
     217    typedef wchar_t*               wchar_iterator_t;
     218
     219    test_string<wchar_t, 13> a_wide_string(L"a wide string");
     220    test_string<wchar_t, 19> another_wide_string(L"another wide string");
     221   
     222    const wchar_t*  char_ws      = a_wide_string.const_sz();
    186223    wchar_t         my_wstring[] = L"another wide string";
    187     wchar_t*        char_ws2     = L"a wide string";
     224    wchar_t*        char_ws2     = a_wide_string.mutable_sz();
    188225           
    189226    BOOST_STATIC_ASSERT(( is_same< range_value<wchar_iterator_t>::type,
     
    204241
    205242    wchar_t to_search = L'n';
    206     BOOST_CHECK( find( char_ws, to_search ) != str_end(char_ws) );   
     243    BOOST_CHECK( find( char_ws, to_search ) != str_end(char_ws) );
     244    BOOST_CHECK( find( char_ws2, to_search ) != str_end(char_ws2) );
    207245
    208246#if BOOST_WORKAROUND(_MSC_VER, BOOST_TESTED_AT(1300))
     
    210248    BOOST_CHECK( find( my_wstring, to_search ) != str_end(my_wstring) );
    211249
     250#else
     251
     252    boost::ignore_unused_variable_warning( my_wstring );
     253   
    212254#endif 
    213255#endif
Note: See TracChangeset for help on using the changeset viewer.