ossrv_pub/boost_apis/boost/range/end.hpp
changeset 31 ce057bb09d0b
parent 0 e4d67989cc36
equal deleted inserted replaced
30:e20de85af2ee 31:ce057bb09d0b
       
     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_END_HPP
       
    12 #define BOOST_RANGE_END_HPP
       
    13 
       
    14 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
       
    15 # pragma once
       
    16 #endif
       
    17 
       
    18 #include <boost/type_traits/remove_const.hpp>
       
    19 #include <boost/range/config.hpp>
       
    20 
       
    21 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
       
    22 #include <boost/range/detail/end.hpp>
       
    23 #else
       
    24 
       
    25 #include <boost/range/detail/implementation_help.hpp>
       
    26 #include <boost/range/iterator.hpp>
       
    27 #include <boost/range/const_iterator.hpp>
       
    28 
       
    29 namespace boost
       
    30 {
       
    31 
       
    32 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
       
    33     !BOOST_WORKAROUND(__GNUC__, < 3) \
       
    34     /**/
       
    35 namespace range_detail
       
    36 {
       
    37 #endif
       
    38 
       
    39         //////////////////////////////////////////////////////////////////////
       
    40         // primary template
       
    41         //////////////////////////////////////////////////////////////////////
       
    42 
       
    43         template< typename C >
       
    44         inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
       
    45         boost_range_end( const C& c )
       
    46         {
       
    47             return c.end();
       
    48         }
       
    49 
       
    50         template< typename C >
       
    51                 inline BOOST_DEDUCED_TYPENAME range_iterator<
       
    52                                         typename remove_const<C>::type >::type
       
    53         boost_range_end( C& c )
       
    54         {
       
    55             return c.end();
       
    56         }
       
    57 
       
    58         //////////////////////////////////////////////////////////////////////
       
    59         // pair
       
    60         //////////////////////////////////////////////////////////////////////
       
    61 
       
    62         template< typename Iterator >
       
    63         inline Iterator boost_range_end( const std::pair<Iterator,Iterator>& p )
       
    64         {
       
    65             return p.second;
       
    66         }
       
    67 
       
    68         template< typename Iterator >
       
    69         inline Iterator boost_range_end( std::pair<Iterator,Iterator>& p )
       
    70         {
       
    71             return p.second;
       
    72         }
       
    73 
       
    74         //////////////////////////////////////////////////////////////////////
       
    75         // array
       
    76         //////////////////////////////////////////////////////////////////////
       
    77 
       
    78         template< typename T, std::size_t sz >
       
    79         inline const T* boost_range_end( const T (&array)[sz] )
       
    80         {
       
    81             return range_detail::array_end<T,sz>( array );
       
    82         }
       
    83 
       
    84         template< typename T, std::size_t sz >
       
    85         inline T* boost_range_end( T (&array)[sz] )
       
    86         {
       
    87             return range_detail::array_end<T,sz>( array );
       
    88         }
       
    89 
       
    90         //////////////////////////////////////////////////////////////////////
       
    91         // string
       
    92         //////////////////////////////////////////////////////////////////////
       
    93 
       
    94 #if 1 || BOOST_WORKAROUND(__MWERKS__, <= 0x3204 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
       
    95 // CW up to 9.3 and borland have troubles with function ordering
       
    96         inline char* boost_range_end( char* s )
       
    97         {
       
    98             return range_detail::str_end( s );
       
    99         }
       
   100 
       
   101         inline wchar_t* boost_range_end( wchar_t* s )
       
   102         {
       
   103             return range_detail::str_end( s );
       
   104         }
       
   105 
       
   106         inline const char* boost_range_end( const char* s )
       
   107         {
       
   108             return range_detail::str_end( s );
       
   109         }
       
   110 
       
   111         inline const wchar_t* boost_range_end( const wchar_t* s )
       
   112         {
       
   113             return range_detail::str_end( s );
       
   114         }
       
   115 #else
       
   116         inline char* boost_range_end( char*& s )
       
   117         {
       
   118             return range_detail::str_end( s );
       
   119         }
       
   120 
       
   121         inline wchar_t* boost_range_end( wchar_t*& s )
       
   122         {
       
   123             return range_detail::str_end( s );
       
   124         }
       
   125 
       
   126         inline const char* boost_range_end( const char*& s )
       
   127         {
       
   128             return range_detail::str_end( s );
       
   129         }
       
   130 
       
   131         inline const wchar_t* boost_range_end( const wchar_t*& s )
       
   132         {
       
   133             return range_detail::str_end( s );
       
   134         }
       
   135 #endif
       
   136 
       
   137 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
       
   138     !BOOST_WORKAROUND(__GNUC__, < 3) \
       
   139     /**/
       
   140 } // namespace 'range_detail'
       
   141 #endif
       
   142 
       
   143 template< class T >
       
   144 inline BOOST_DEDUCED_TYPENAME range_iterator<
       
   145                 typename remove_const<T>::type >::type end( T& r )
       
   146 {
       
   147 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
       
   148     !BOOST_WORKAROUND(__GNUC__, < 3) \
       
   149     /**/
       
   150     using namespace range_detail;
       
   151 #endif
       
   152     return boost_range_end( r );
       
   153 }
       
   154 
       
   155 template< class T >
       
   156 inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type end( const T& r )
       
   157 {
       
   158 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
       
   159     !BOOST_WORKAROUND(__GNUC__, < 3) \
       
   160     /**/
       
   161     using namespace range_detail;
       
   162 #endif
       
   163     return boost_range_end( r );
       
   164 }
       
   165 
       
   166 
       
   167 
       
   168 #if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
       
   169 // BCB and CW are not able to overload pointer when class overloads are also available.
       
   170 template<>
       
   171 inline range_const_iterator<const char*>::type end<const char*>( const char*& r )
       
   172 {
       
   173     return range_detail::str_end( r );
       
   174 }
       
   175 
       
   176 template<>
       
   177 inline range_const_iterator<const wchar_t*>::type end<const wchar_t*>( const wchar_t*& r )
       
   178 {
       
   179     return range_detail::str_end( r );
       
   180 }
       
   181 
       
   182 #endif
       
   183 
       
   184 } // namespace 'boost'
       
   185 
       
   186 
       
   187 
       
   188 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
       
   189 
       
   190 
       
   191 namespace boost
       
   192 {
       
   193     template< class T >
       
   194     inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
       
   195     const_end( const T& r )
       
   196     {
       
   197         return boost::end( r );
       
   198     }
       
   199 }
       
   200 
       
   201 #endif