epoc32/include/stdapis/boost/range/sub_range.hpp
author William Roberts <williamr@symbian.org>
Tue, 16 Mar 2010 16:12:26 +0000
branchSymbian2
changeset 2 2fe1408b6811
permissions -rw-r--r--
Final list of Symbian^2 public API header files
     1 // Boost.Range library
     2 //
     3 //  Copyright Thorsten Ottosen 2003-2004. Use, modification and
     4 //  distribution is subject to the Boost Software License, Version
     5 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
     6 //  http://www.boost.org/LICENSE_1_0.txt)
     7 //
     8 // For more information, see http://www.boost.org/libs/range/
     9 //
    10 
    11 #ifndef BOOST_RANGE_SUB_RANGE_HPP
    12 #define BOOST_RANGE_SUB_RANGE_HPP
    13 
    14 #include <boost/range/config.hpp>
    15 #include <boost/range/iterator_range.hpp>
    16 #include <boost/range/value_type.hpp>
    17 #include <boost/range/result_iterator.hpp>
    18 #include <boost/range/size_type.hpp>
    19 #include <boost/range/difference_type.hpp>
    20 #include <boost/assert.hpp>
    21 
    22 namespace boost
    23 {
    24     
    25     template< class ForwardRange > 
    26     class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type > 
    27     {
    28         typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type iterator_t;
    29         typedef iterator_range< iterator_t  > base;
    30 
    31         typedef BOOST_DEDUCED_TYPENAME base::impl impl;
    32     public:
    33         typedef BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type            value_type;
    34         typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type  iterator;
    35         typedef BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type   const_iterator;
    36         typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type       difference_type;
    37         typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type             size_type;
    38         typedef BOOST_DEDUCED_TYPENAME base::reference                            reference;
    39         typedef BOOST_DEDUCED_TYPENAME iterator_reference<const_iterator>::type   const_reference;
    40 
    41     public:
    42         sub_range() : base() 
    43         { }
    44 
    45 /*        
    46         template< class ForwardRange2 >
    47         sub_range( sub_range<ForwardRange2> r ) :
    48 
    49 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
    50             base( impl::adl_begin( r ), impl::adl_end( r ) )
    51 #else
    52             base( r )
    53 #endif */
    54 
    55         template< class ForwardRange2 >
    56         sub_range( ForwardRange2& r ) : 
    57             
    58 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
    59             base( impl::adl_begin( r ), impl::adl_end( r ) )
    60 #else
    61             base( r )
    62 #endif        
    63         { }
    64         
    65         template< class ForwardRange2 >
    66         sub_range( const ForwardRange2& r ) : 
    67 
    68 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
    69             base( impl::adl_begin( r ), impl::adl_end( r ) )
    70 #else
    71             base( r )
    72 #endif                
    73         { }
    74 
    75         template< class Iter >
    76         sub_range( Iter first, Iter last ) :
    77             base( first, last )
    78         { }
    79         
    80         template< class ForwardRange2 >
    81         sub_range& operator=( ForwardRange2& r )
    82         {
    83             base::operator=( r );
    84             return *this;
    85         }
    86 
    87         template< class ForwardRange2 >
    88         sub_range& operator=( const ForwardRange2& r )
    89         {
    90             base::operator=( r );
    91             return *this;
    92         }
    93 
    94         sub_range& operator=( sub_range r )
    95         {
    96             //
    97             // argument passed by value to avoid 
    98             // const_iterator to iterator conversion
    99             //
   100             base::operator=( r );
   101             return *this;            
   102         }
   103         
   104     public:
   105         
   106         iterator        begin()          { return base::begin(); }
   107         const_iterator  begin() const    { return base::begin(); }
   108         iterator        end()            { return base::end();   }
   109         const_iterator  end() const      { return base::end();   }
   110         size_type       size() const     { return base::size();  }   
   111 
   112         
   113     public: // convenience
   114         reference front()
   115         {
   116             return base::front();
   117         }
   118 
   119         const_reference front() const
   120         {
   121             return base::front();
   122         }
   123 
   124         reference back()
   125         {
   126             return base::back();
   127         }
   128 
   129         const_reference back() const
   130         {
   131             return base::back();
   132         }
   133 
   134         reference operator[]( size_type sz )
   135         {
   136             return base::operator[](sz);
   137         }
   138 
   139         const_reference operator[]( size_type sz ) const
   140         {
   141             return base::operator[](sz);
   142         }
   143 
   144     };
   145 
   146     template< class ForwardRange, class ForwardRange2 >
   147     inline bool operator==( const sub_range<ForwardRange>& l,
   148                             const sub_range<ForwardRange2>& r )
   149     {
   150         return iterator_range_detail::equal( l, r );
   151     }
   152 
   153     template< class ForwardRange, class ForwardRange2 >
   154     inline bool operator!=( const sub_range<ForwardRange>& l,
   155                             const sub_range<ForwardRange2>& r )
   156     {
   157         return !iterator_range_detail::equal( l, r );
   158     }
   159 
   160     template< class ForwardRange, class ForwardRange2 >
   161     inline bool operator<( const sub_range<ForwardRange>& l,
   162                            const sub_range<ForwardRange2>& r )
   163     {
   164         return iterator_range_detail::less_than( l, r );
   165     }
   166 
   167 
   168 } // namespace 'boost'
   169 
   170 #endif