feedc0de/boost_range
1
0
Fork 0
forked from boostorg/range
Code Pull Requests Activity

upgrade to v2

Browse Source 
[SVN r34012]
This commit is contained in:
Thorsten Jørgen Ottosen
2006-05-18 20:52:17 +00:00
parent dc96b440be
commit 554f832234
25 changed files with 248 additions and 1291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
include/boost/range/begin.hpp
View File

@ -15,7 +15,6 @@
# pragma once
#endif
#include <boost/type_traits/remove_const.hpp>
#include <boost/range/config.hpp>
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@ -23,7 +22,6 @@
#else
#include <boost/range/iterator.hpp>
#include <boost/range/const_iterator.hpp>
namespace boost
{
@ -40,16 +38,8 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
template< typename C >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
boost_range_begin( const C& c )
{
return c.begin();
}
template< typename C >
inline BOOST_DEDUCED_TYPENAME range_iterator<
typename remove_const<C>::type >::type
boost_range_begin( C& c )
inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
range_begin( C& c )
{
return c.begin();
}
@ -59,13 +49,13 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
template< typename Iterator >
inline Iterator boost_range_begin( const std::pair<Iterator,Iterator>& p )
inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
{
return p.first;
}
template< typename Iterator >
inline Iterator boost_range_begin( std::pair<Iterator,Iterator>& p )
inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
{
return p.first;
}
@ -74,66 +64,22 @@ namespace range_detail
// array
//////////////////////////////////////////////////////////////////////
//
// May this be discarded? Or is it needed for bad compilers?
//
template< typename T, std::size_t sz >
inline const T* boost_range_begin( const T (&array)[sz] )
inline const T* range_begin( const T (&array)[sz] )
{
return array;
}
template< typename T, std::size_t sz >
inline T* boost_range_begin( T (&array)[sz] )
inline T* range_begin( T (&array)[sz] )
{
return array;
}
//////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////
#if 1 || BOOST_WORKAROUND(__MWERKS__, <= 0x3204 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
// CW up to 9.3 and borland have troubles with function ordering
inline const char* boost_range_begin( const char* s )
{
return s;
}
inline char* boost_range_begin( char* s )
{
return s;
}
inline const wchar_t* boost_range_begin( const wchar_t* s )
{
return s;
}
inline wchar_t* boost_range_begin( wchar_t* s )
{
return s;
}
#else
inline const char* boost_range_begin( const char*& s )
{
return s;
}
inline char* boost_range_begin( char*& s )
{
return s;
}
inline const wchar_t* boost_range_begin( const wchar_t*& s )
{
return s;
}
inline wchar_t* boost_range_begin( wchar_t*& s )
{
return s;
}
#endif
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
@ -142,44 +88,27 @@ namespace range_detail
template< class T >
inline BOOST_DEDUCED_TYPENAME range_iterator<
typename remove_const<T>::type >::type begin( T& r )
inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
using namespace range_detail;
#endif
return boost_range_begin( r );
return range_begin( r );
}
template< class T >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type begin( const T& r )
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
using namespace range_detail;
#endif
return boost_range_begin( r );
return range_begin( r );
}
#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
// BCB and CW are not able to overload pointer when class overloads are also available.
template<>
inline range_const_iterator<const char*>::type begin<const char*>( const char*& r )
{
return r;
}
template<>
inline range_const_iterator<const wchar_t*>::type begin<const wchar_t*>( const wchar_t*& r )
{
return r;
}
#endif
} // namespace boost
#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@ -187,7 +116,7 @@ inline range_const_iterator<const wchar_t*>::type begin<const wchar_t*>( const w
namespace boost
{
template< class T >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
const_begin( const T& r )
{
return boost::begin( r );
@ -195,3 +124,4 @@ namespace boost
}
#endif

65
include/boost/range/const_iterator.hpp
View File

@ -21,6 +21,7 @@
#include <boost/range/detail/const_iterator.hpp>
#else
#include <boost/type_traits/remove_const.hpp>
#include <cstddef>
#include <utility>
@ -46,12 +47,6 @@ namespace boost
typedef Iterator type;
};
template< typename Iterator >
struct range_const_iterator< const std::pair<Iterator,Iterator> >
{
typedef Iterator type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
@ -62,64 +57,6 @@ namespace boost
typedef const T* type;
};
template< typename T, std::size_t sz >
struct range_const_iterator< const T[sz] >
{
typedef const T* type;
};
//////////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////////
template<>
struct range_const_iterator< char* >
{
typedef const char* type;
};
template<>
struct range_const_iterator< wchar_t* >
{
typedef const wchar_t* type;
};
template<>
struct range_const_iterator< const char* >
{
typedef const char* type;
};
template<>
struct range_const_iterator< const wchar_t* >
{
typedef const wchar_t* type;
};
template<>
struct range_const_iterator< char* const >
{
typedef const char* type;
};
template<>
struct range_const_iterator< wchar_t* const >
{
typedef const wchar_t* type;
};
template<>
struct range_const_iterator< const char* const >
{
typedef const char* type;
};
template<>
struct range_const_iterator< const wchar_t* const >
{
typedef const wchar_t* type;
};
} // namespace boost
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

17
include/boost/range/const_reverse_iterator.hpp
View File

@ -15,22 +15,17 @@
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/iterator/reverse_iterator.hpp>
#include <boost/range/reverse_iterator.hpp>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
//
// This interface is deprecated, use range_reverse_iterator<const T>
//
template< typename C >
struct range_const_reverse_iterator
{
typedef reverse_iterator<
BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type > type;
};
struct range_const_reverse_iterator : range_reverse_iterator<const C>
{ };
} // namespace boost

49
include/boost/range/detail/begin.hpp
View File

@ -13,7 +13,7 @@
#include <boost/config.hpp> // BOOST_MSVC
#include <boost/detail/workaround.hpp>
#include <boost/range/result_iterator.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/detail/common.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
# include <boost/range/value_type.hpp>
@ -35,7 +35,7 @@ namespace boost
struct range_begin<std_container_>
{
template< typename C >
static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type fun( C& c )
static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type fun( C& c )
{
return c.begin();
};
@ -49,7 +49,7 @@ namespace boost
struct range_begin<std_pair_>
{
template< typename P >
static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type fun( const P& p )
static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type fun( const P& p )
{
return p.first;
}
@ -77,51 +77,10 @@ namespace boost
#endif
};
//////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////
template<>
struct range_begin<char_ptr_>
{
static char* fun( char* s )
{
return s;
}
};
template<>
struct range_begin<const_char_ptr_>
{
static const char* fun( const char* s )
{
return s;
}
};
template<>
struct range_begin<wchar_t_ptr_>
{
static wchar_t* fun( wchar_t* s )
{
return s;
}
};
template<>
struct range_begin<const_wchar_t_ptr_>
{
static const wchar_t* fun( const wchar_t* s )
{
return s;
}
};
} // namespace 'range_detail'
template< typename C >
inline BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type
inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
begin( C& c )
{
return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );

1
include/boost/range/detail/common.hpp
View File

@ -114,3 +114,4 @@ namespace boost
}
#endif

52
include/boost/range/detail/const_iterator.hpp
View File

@ -56,58 +56,6 @@ namespace boost
remove_extent<T>::type* type;
};
};
template<>
struct range_const_iterator_<char_array_>
{
template< typename T >
struct pts
{
typedef const BOOST_RANGE_DEDUCED_TYPENAME
remove_extent<T>::type* type;
};
};
template<>
struct range_const_iterator_<char_ptr_>
{
template< typename S >
struct pts
{
typedef const char* type;
};
};
template<>
struct range_const_iterator_<const_char_ptr_>
{
template< typename S >
struct pts
{
typedef const char* type;
};
};
template<>
struct range_const_iterator_<wchar_t_ptr_>
{
template< typename S >
struct pts
{
typedef const wchar_t* type;
};
};
template<>
struct range_const_iterator_<const_wchar_t_ptr_>
{
template< typename S >
struct pts
{
typedef const wchar_t* type;
};
};
}
template< typename C >

71
include/boost/range/detail/end.hpp
View File

@ -18,8 +18,7 @@
# include <boost/range/detail/vc6/end.hpp>
#else
# include <boost/range/detail/implementation_help.hpp>
# include <boost/range/detail/implementation_help.hpp>
# include <boost/range/result_iterator.hpp>
# include <boost/range/iterator.hpp>
# include <boost/range/detail/common.hpp>
# if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
# include <boost/range/detail/remove_extent.hpp>
@ -40,7 +39,7 @@ namespace boost
struct range_end<std_container_>
{
template< typename C >
static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type
static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
fun( C& c )
{
return c.end();
@ -55,7 +54,7 @@ namespace boost
struct range_end<std_pair_>
{
template< typename P >
static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type
static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type
fun( const P& p )
{
return p.second;
@ -83,73 +82,11 @@ namespace boost
}
#endif
};
template<>
struct range_end<char_array_>
{
template< typename T, std::size_t sz >
static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
{
return boost::range_detail::array_end( boost_range_array );
}
};
template<>
struct range_end<wchar_t_array_>
{
template< typename T, std::size_t sz >
static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
{
return boost::range_detail::array_end( boost_range_array );
}
};
//////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////
template<>
struct range_end<char_ptr_>
{
static char* fun( char* s )
{
return boost::range_detail::str_end( s );
}
};
template<>
struct range_end<const_char_ptr_>
{
static const char* fun( const char* s )
{
return boost::range_detail::str_end( s );
}
};
template<>
struct range_end<wchar_t_ptr_>
{
static wchar_t* fun( wchar_t* s )
{
return boost::range_detail::str_end( s );
}
};
template<>
struct range_end<const_wchar_t_ptr_>
{
static const wchar_t* fun( const wchar_t* s )
{
return boost::range_detail::str_end( s );
}
};
} // namespace 'range_detail'
template< typename C >
inline BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type
inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
end( C& c )
{
return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );

52
include/boost/range/detail/iterator.hpp
View File

@ -64,60 +64,10 @@ namespace boost
};
};
template<>
struct range_iterator_<char_array_>
{
template< typename T >
struct pts
{
typedef BOOST_RANGE_DEDUCED_TYPENAME
remove_extent<T>::type* type;
};
};
template<>
struct range_iterator_<char_ptr_>
{
template< typename S >
struct pts
{
typedef char* type;
};
};
template<>
struct range_iterator_<const_char_ptr_>
{
template< typename S >
struct pts
{
typedef const char* type;
};
};
template<>
struct range_iterator_<wchar_t_ptr_>
{
template< typename S >
struct pts
{
typedef wchar_t* type;
};
};
template<>
struct range_iterator_<const_wchar_t_ptr_>
{
template< typename S >
struct pts
{
typedef const wchar_t* type;
};
};
}
template< typename C >
class range_iterator
class range_mutable_iterator
{
typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
public:

50
include/boost/range/detail/size_type.hpp
View File

@ -54,55 +54,7 @@ namespace boost
};
};
template<>
struct range_size_type_<char_array_>
{
template< typename A >
struct pts
{
typedef std::size_t type;
};
};
template<>
struct range_size_type_<char_ptr_>
{
template< typename S >
struct pts
{
typedef std::size_t type;
};
};
template<>
struct range_size_type_<const_char_ptr_>
{
template< typename S >
struct pts
{
typedef std::size_t type;
};
};
template<>
struct range_size_type_<wchar_t_ptr_>
{
template< typename S >
struct pts
{
typedef std::size_t type;
};
};
template<>
struct range_size_type_<const_wchar_t_ptr_>
{
template< typename S >
struct pts
{
typedef std::size_t type;
};
};
}
template< typename C >

50
include/boost/range/detail/value_type.hpp
View File

@ -56,56 +56,6 @@ namespace boost
};
};
template<>
struct range_value_type_<char_array_>
{
template< typename T >
struct pts
{
typedef char type;
};
};
template<>
struct range_value_type_<char_ptr_>
{
template< typename S >
struct pts
{
typedef char type;
};
};
template<>
struct range_value_type_<const_char_ptr_>
{
template< typename S >
struct pts
{
typedef const char type;
};
};
template<>
struct range_value_type_<wchar_t_ptr_>
{
template< typename S >
struct pts
{
typedef wchar_t type;
};
};
template<>
struct range_value_type_<const_wchar_t_ptr_>
{
template< typename S >
struct pts
{
typedef const wchar_t type;
};
};
}
template< typename C >

124
include/boost/range/difference_type.hpp
View File

@ -16,130 +16,14 @@
#endif
#include <boost/range/config.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/range/iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
namespace boost
{
template< class T >
struct range_difference
{
typedef BOOST_DEDUCED_TYPENAME iterator_difference<
BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type >::type
type;
};
template< class T >
struct range_difference : iterator_difference< typename range_iterator<T>::type >
{ };
}
//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
//#include <boost/range/detail/difference_type.hpp>
//#else
/*
#include <cstddef>
#include <utility>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename C >
struct range_difference
{
typedef BOOST_DEDUCED_TYPENAME C::difference_type type;
};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_difference< std::pair<Iterator,Iterator> >
{
typedef BOOST_DEDUCED_TYPENAME
iterator_difference<Iterator>::type type;
};
template< typename Iterator >
struct range_difference< const std::pair<Iterator,Iterator> >
{
typedef BOOST_DEDUCED_TYPENAME
iterator_difference<Iterator>::type type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_difference< T[sz] >
{
typedef std::ptrdiff_t type;
};
template< typename T, std::size_t sz >
struct range_difference< const T[sz] >
{
typedef std::ptrdiff_t type;
};
//////////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////////
template<>
struct range_difference< char* >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< wchar_t* >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< const char* >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< const wchar_t* >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< char* const >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< wchar_t* const >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< const char* const >
{
typedef std::ptrdiff_t type;
};
template<>
struct range_difference< const wchar_t* const >
{
typedef std::ptrdiff_t type;
};
} // namespace boost
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
*/
#endif

43
include/boost/range/empty.hpp
View File

@ -16,52 +16,19 @@
#endif
#include <boost/range/config.hpp>
//#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
//#include <boost/range/detail/empty.hpp>
//#else
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
namespace boost
{
namespace range_detail
{
//////////////////////////////////////////////////////////////////////
// primary template
//////////////////////////////////////////////////////////////////////
template< typename C >
inline bool empty( const C& c )
{
return boost::begin( c ) == boost::end( c );
}
//////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////
inline bool empty( const char* const& s )
{
return s == 0 || s[0] == 0;
}
inline bool empty( const wchar_t* const& s )
{
return s == 0 || s[0] == 0;
}
} // namespace 'range_detail'
template< class T >
inline bool empty( const T& r )
{
return range_detail::empty( r );
}
template< class T >
inline bool empty( const T& r )
{
return boost::begin( r ) == boost::end( r );
}
} // namepace 'boost'
//#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#endif

99
include/boost/range/end.hpp
View File

@ -15,7 +15,6 @@
# pragma once
#endif
#include <boost/type_traits/remove_const.hpp>
#include <boost/range/config.hpp>
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@ -39,18 +38,9 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
// primary template
//////////////////////////////////////////////////////////////////////
template< typename C >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
boost_range_end( const C& c )
{
return c.end();
}
template< typename C >
inline BOOST_DEDUCED_TYPENAME range_iterator<
typename remove_const<C>::type >::type
boost_range_end( C& c )
inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
range_end( C& c )
{
return c.end();
}
@ -60,13 +50,13 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
template< typename Iterator >
inline Iterator boost_range_end( const std::pair<Iterator,Iterator>& p )
inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
{
return p.second;
}
template< typename Iterator >
inline Iterator boost_range_end( std::pair<Iterator,Iterator>& p )
inline Iterator range_end( std::pair<Iterator,Iterator>& p )
{
return p.second;
}
@ -76,64 +66,17 @@ namespace range_detail
//////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
inline const T* boost_range_end( const T (&array)[sz] )
inline const T* range_end( const T (&array)[sz] )
{
return range_detail::array_end<T,sz>( array );
}
template< typename T, std::size_t sz >
inline T* boost_range_end( T (&array)[sz] )
inline T* range_end( T (&array)[sz] )
{
return range_detail::array_end<T,sz>( array );
}
//////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////
#if 1 || BOOST_WORKAROUND(__MWERKS__, <= 0x3204 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
// CW up to 9.3 and borland have troubles with function ordering
inline char* boost_range_end( char* s )
{
return range_detail::str_end( s );
}
inline wchar_t* boost_range_end( wchar_t* s )
{
return range_detail::str_end( s );
}
inline const char* boost_range_end( const char* s )
{
return range_detail::str_end( s );
}
inline const wchar_t* boost_range_end( const wchar_t* s )
{
return range_detail::str_end( s );
}
#else
inline char* boost_range_end( char*& s )
{
return range_detail::str_end( s );
}
inline wchar_t* boost_range_end( wchar_t*& s )
{
return range_detail::str_end( s );
}
inline const char* boost_range_end( const char*& s )
{
return range_detail::str_end( s );
}
inline const wchar_t* boost_range_end( const wchar_t*& s )
{
return range_detail::str_end( s );
}
#endif
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
@ -141,46 +84,27 @@ namespace range_detail
#endif
template< class T >
inline BOOST_DEDUCED_TYPENAME range_iterator<
typename remove_const<T>::type >::type end( T& r )
inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
using namespace range_detail;
#endif
return boost_range_end( r );
return range_end( r );
}
template< class T >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type end( const T& r )
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
!BOOST_WORKAROUND(__GNUC__, < 3) \
/**/
using namespace range_detail;
#endif
return boost_range_end( r );
return range_end( r );
}
#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
// BCB and CW are not able to overload pointer when class overloads are also available.
template<>
inline range_const_iterator<const char*>::type end<const char*>( const char*& r )
{
return range_detail::str_end( r );
}
template<>
inline range_const_iterator<const wchar_t*>::type end<const wchar_t*>( const wchar_t*& r )
{
return range_detail::str_end( r );
}
#endif
} // namespace 'boost'
@ -191,7 +115,7 @@ inline range_const_iterator<const wchar_t*>::type end<const wchar_t*>( const wch
namespace boost
{
template< class T >
inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
const_end( const T& r )
{
return boost::end( r );
@ -199,3 +123,4 @@ namespace boost
}
#endif

4
include/boost/range/functions.hpp
View File

@ -1,6 +1,6 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// Copyright Thorsten Ottosen 2003-2006. Use, modification and
// distribution is subject to 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)
@ -18,8 +18,10 @@
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/size.hpp>
#include <boost/range/distance.hpp>
#include <boost/range/empty.hpp>
#include <boost/range/rbegin.hpp>
#include <boost/range/rend.hpp>
#endif

110
include/boost/range/iterator.hpp
View File

@ -11,118 +11,30 @@
#ifndef BOOST_RANGE_ITERATOR_HPP
#define BOOST_RANGE_ITERATOR_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/range/config.hpp>
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#include <boost/range/detail/iterator.hpp>
#else
#include <boost/iterator/iterator_traits.hpp>
#include <cstddef>
#include <utility>
#include <boost/range/mutable_iterator.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/mpl/eval_if.hpp>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename C >
struct range_iterator
{
typedef BOOST_DEDUCED_TYPENAME C::iterator type;
typedef BOOST_RANGE_DEDUCED_TYPENAME
mpl::eval_if_c< is_const<C>::value,
range_const_iterator< typename remove_const<C>::type >,
range_mutable_iterator<C> >::type type;
};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_iterator< std::pair<Iterator,Iterator> >
{
typedef Iterator type;
};
template< typename Iterator >
struct range_iterator< const std::pair<Iterator,Iterator> >
{
typedef Iterator type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_iterator< T[sz] >
{
typedef T* type;
};
template< typename T, std::size_t sz >
struct range_iterator< const T[sz] >
{
typedef const T* type;
};
//////////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////////
template<>
struct range_iterator< char* >
{
typedef char* type;
};
template<>
struct range_iterator< wchar_t* >
{
typedef wchar_t* type;
};
template<>
struct range_iterator< const char* >
{
typedef const char* type;
};
template<>
struct range_iterator< const wchar_t* >
{
typedef const wchar_t* type;
};
template<>
struct range_iterator< char* const >
{
typedef char* type;
};
template<>
struct range_iterator< wchar_t* const >
{
typedef wchar_t* type;
};
template<>
struct range_iterator< const char* const >
{
typedef const char* type;
};
template<>
struct range_iterator< const wchar_t* const >
{
typedef const wchar_t* type;
};
} // namespace boost
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif

137
include/boost/range/iterator_range.hpp
View File

@ -23,7 +23,7 @@
#include <boost/detail/workaround.hpp>
#include <boost/range/functions.hpp>
#include <boost/range/result_iterator.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/assert.hpp>
@ -158,8 +158,11 @@ namespace boost
//! iterator type
typedef IteratorT iterator;
iterator_range() : m_Begin( iterator() ), m_End( iterator() ),
singular( true )
iterator_range() : m_Begin( iterator() ), m_End( iterator() )
#ifndef NDEBUG
, singular( true )
#endif
{ }
/*
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
@ -178,41 +181,57 @@ namespace boost
//! Constructor from a pair of iterators
template< class Iterator >
iterator_range( Iterator Begin, Iterator End ) :
m_Begin(Begin), m_End(End), singular(false) {}
m_Begin(Begin), m_End(End)
#ifndef NDEBUG
, singular(false)
#endif
{}
//! Constructor from a Range
template< class Range >
iterator_range( const Range& r ) :
m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ),
singular(false) {}
m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
#ifndef NDEBUG
, singular(false)
#endif
{}
//! Constructor from a Range
template< class Range >
iterator_range( Range& r ) :
m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ),
singular(false) {}
m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
#ifndef NDEBUG
, singular(false)
#endif
{}
//! Constructor from a Range
template< class Range >
iterator_range( const Range& r, iterator_range_detail::const_range_tag ) :
m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ),
singular(false) {}
m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
#ifndef NDEBUG
, singular(false)
#endif
{}
//! Constructor from a Range
template< class Range >
iterator_range( Range& r, iterator_range_detail::range_tag ) :
m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ),
singular(false) {}
m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
#ifndef NDEBUG
, singular(false)
#endif
{}
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
this_type& operator=( const this_type& r )
{
m_Begin = r.begin();
m_End = r.end();
//
// remark: this need not necessarily be true, but it does no harm
//
#ifndef NDEBUG
singular = r.singular;
#endif
return *this;
}
#endif
@ -222,10 +241,9 @@ namespace boost
{
m_Begin = r.begin();
m_End = r.end();
//
// remark: this need not necessarily be true, but it does no harm
//
singular = r.empty();
#ifndef NDEBUG
singular = r.is_singular();
#endif
return *this;
}
@ -234,7 +252,9 @@ namespace boost
{
m_Begin = impl::adl_begin( r );
m_End = impl::adl_end( r );
#ifndef NDEBUG
singular = false;
#endif
return *this;
}
@ -243,33 +263,33 @@ namespace boost
{
m_Begin = impl::adl_begin( r );
m_End = impl::adl_end( r );
#ifndef NDEBUG
singular = false;
#endif
return *this;
}
IteratorT begin() const
{
BOOST_ASSERT( !is_singular() );
return m_Begin;
}
IteratorT end() const
{
BOOST_ASSERT( !is_singular() );
return m_End;
}
size_type size() const
{
if( singular )
return 0;
return std::distance( m_Begin, m_End );
BOOST_ASSERT( !is_singular() );
return m_End - m_Begin;
}
bool empty() const
{
if( singular )
return true;
BOOST_ASSERT( !is_singular() );
return m_Begin == m_End;
}
@ -288,7 +308,8 @@ namespace boost
bool equal( const iterator_range& r ) const
{
return singular == r.singular && m_Begin == r.m_Begin && m_End == r.m_End;
BOOST_ASSERT( !is_singular() );
return m_Begin == r.m_Begin && m_End == r.m_End;
}
@ -296,17 +317,20 @@ namespace boost
bool operator==( const iterator_range& r ) const
{
BOOST_ASSERT( !is_singular() );
return iterator_range_detail::equal( *this, r );
}
bool operator!=( const iterator_range& r ) const
{
BOOST_ASSERT( !is_singular() );
return !operator==(r);
}
bool operator<( const iterator_range& r ) const
{
return iterator_range_detail::less_than( *this, r );
BOOST_ASSERT( !is_singular() );
return iterator_range_detail::less_than( *this, r );
}
#endif
@ -327,19 +351,20 @@ namespace boost
reference operator[]( size_type sz ) const
{
//BOOST_STATIC_ASSERT( is_random_access );
BOOST_ASSERT( sz < size() );
return m_Begin[sz];
}
iterator_range& advance_begin( difference_type n )
{
BOOST_ASSERT( !is_singular() );
std::advance( m_Begin, n );
return *this;
}
iterator_range& advance_end( difference_type n )
{
BOOST_ASSERT( !is_singular() );
std::advance( m_End, n );
return *this;
}
@ -348,24 +373,23 @@ namespace boost
// begin and end iterators
IteratorT m_Begin;
IteratorT m_End;
#ifndef NDEBUG
bool singular;
#endif
#ifndef NDEBUG
public:
bool is_singular() const
{
return singular;
}
#endif
};
// iterator range free-standing operators ---------------------------//
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#else
template< class Iterator >
inline bool empty( const iterator_range<Iterator>& r )
{
//
// this will preserve the well-defined empty() even
// though 'r' is singular.
//
return r.empty();
}
#endif
#ifndef BOOST_OLD_IOSTREAMS
//! iterator_range output operator
@ -380,7 +404,7 @@ namespace boost
{
std::copy( r.begin(), r.end(),
std::ostream_iterator< BOOST_DEDUCED_TYPENAME
iterator_value<IteratorT>::type,
iterator_value<IteratorT>::type,
Elem, Traits>(Os) );
return Os;
}
@ -496,10 +520,10 @@ namespace boost
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template< typename Range >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
make_iterator_range( Range& r )
{
return iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
( boost::begin( r ), boost::end( r ) );
}
@ -518,10 +542,10 @@ namespace boost
}
template< class ForwardRange >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
make_iterator_range( const ForwardRange& r )
{
return iterator_range< BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type >
return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
( r, iterator_range_detail::const_range_tag() );
}
@ -530,15 +554,19 @@ namespace boost
namespace iterator_range_detail
{
template< class Range >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
make_range_impl( Range& r,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
{
if( advance_begin == 0 && advance_end == 0 )
return make_iterator_range( r );
//
// Not worth the effort
//
//if( advance_begin == 0 && advance_end == 0 )
// return make_iterator_range( r );
//
BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type
BOOST_DEDUCED_TYPENAME range_iterator<Range>::type
new_begin = boost::begin( r ),
new_end = boost::end( r );
std::advance( new_begin, advance_begin );
@ -550,7 +578,7 @@ namespace boost
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template< class Range >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
make_iterator_range( Range& r,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
@ -572,7 +600,7 @@ namespace boost
}
template< class Range >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_const_iterator<Range>::type >
inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
make_iterator_range( const Range& r,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
@ -602,3 +630,4 @@ namespace boost
#undef BOOST_OLD_IOSTREAMS
#endif

10
include/boost/range/metafunctions.hpp
View File

@ -16,13 +16,15 @@
#endif
#include <boost/range/iterator.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/size_type.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/result_iterator.hpp>
#include <boost/range/reverse_iterator.hpp>
#include <boost/range/const_reverse_iterator.hpp>
#include <boost/range/reverse_result_iterator.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/size_type.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/range/category.hpp>
#include <boost/range/reference.hpp>
#include <boost/range/pointer.hpp>
#endif

19
include/boost/range/rbegin.hpp
View File

@ -16,9 +16,7 @@
#endif
#include <boost/range/end.hpp>
#include <boost/range/reverse_result_iterator.hpp>
#include <boost/range/reverse_iterator.hpp>
#include <boost/range/const_reverse_iterator.hpp>
namespace boost
{
@ -26,30 +24,28 @@ namespace boost
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template< class C >
inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
rbegin( C& c )
{
return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( end( c ) );
return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::end( c ) );
}
#else
template< class C >
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<
typename remove_const<C>::type >::type
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
rbegin( C& c )
{
typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<
typename remove_const<C>::type >::type
typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
iter_type;
return iter_type( boost::end( c ) );
}
template< class C >
inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
rbegin( const C& c )
{
typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
iter_type;
return iter_type( boost::end( c ) );
}
@ -57,7 +53,7 @@ rbegin( const C& c )
#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template< class T >
inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
const_rbegin( const T& r )
{
return boost::rbegin( r );
@ -66,3 +62,4 @@ const_rbegin( const T& r )
} // namespace 'boost'
#endif

19
include/boost/range/rend.hpp
View File

@ -16,9 +16,7 @@
#endif
#include <boost/range/begin.hpp>
#include <boost/range/reverse_result_iterator.hpp>
#include <boost/range/reverse_iterator.hpp>
#include <boost/range/const_reverse_iterator.hpp>
namespace boost
{
@ -26,30 +24,28 @@ namespace boost
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template< class C >
inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
rend( C& c )
{
return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( boost::begin( c ) );
return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::begin( c ) );
}
#else
template< class C >
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<
typename remove_const<C>::type >::type
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
rend( C& c )
{
typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<
typename remove_const<C>::type >::type
typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
iter_type;
return iter_type( boost::begin( c ) );
}
template< class C >
inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
rend( const C& c )
{
typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
iter_type;
return iter_type( boost::begin( c ) );
}
@ -57,7 +53,7 @@ rend( const C& c )
#endif
template< class T >
inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
const_rend( const T& r )
{
return boost::rend( r );
@ -66,3 +62,4 @@ const_rend( const T& r )
} // namespace 'boost'
#endif

20
include/boost/range/result_iterator.hpp
View File

@ -15,29 +15,19 @@
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/mpl/if.hpp>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
//
// This interface is deprecated, use range_iterator<T>
//
template< typename C >
struct range_result_iterator
{
typedef BOOST_RANGE_DEDUCED_TYPENAME
mpl::if_< BOOST_DEDUCED_TYPENAME is_const<C>::type,
BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type,
BOOST_DEDUCED_TYPENAME range_iterator<C>::type >::type type;
};
struct range_result_iterator : range_iterator<C>
{ };
} // namespace boost
//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif

17
include/boost/range/reverse_result_iterator.hpp
View File

@ -15,22 +15,17 @@
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/result_iterator.hpp>
#include <boost/iterator/reverse_iterator.hpp>
#include <boost/range/reverse_iterator.hpp>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
//
// This interface is deprecated, use range_reverse_iterator<T>
//
template< typename C >
struct range_reverse_result_iterator
{
typedef reverse_iterator<
BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type > type;
};
struct range_reverse_result_iterator : range_reverse_iterator<C>
{ };
} // namespace boost

104
include/boost/range/size.hpp
View File

@ -15,109 +15,19 @@
# pragma once
#endif
#include <boost/range/config.hpp>
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#include <boost/range/detail/size.hpp>
#else
#include <boost/range/detail/implementation_help.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/size_type.hpp>
#include <cstddef>
#include <iterator>
#include <utility>
namespace boost
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
namespace range_detail
{
#endif
//////////////////////////////////////////////////////////////////////
// primary template
//////////////////////////////////////////////////////////////////////
template< typename C >
inline BOOST_DEDUCED_TYPENAME C::size_type
boost_range_size( const C& c )
{
return c.size();
}
//////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////
template< typename Iterator >
inline std::size_t boost_range_size( const std::pair<Iterator,Iterator>& p )
{
return std::distance( p.first, p.second );
}
//////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
inline std::size_t boost_range_size( const T (&array)[sz] )
{
return range_detail::array_size<T,sz>( array );
}
template< typename T, std::size_t sz >
inline std::size_t boost_range_size( T (&array)[sz] )
{
return boost::range_detail::array_size<T,sz>( array );
}
//////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////
inline std::size_t boost_range_size( const char* const& s )
{
return boost::range_detail::str_size( s );
}
inline std::size_t boost_range_size( const wchar_t* const& s )
{
return boost::range_detail::str_size( s );
}
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
} // namespace 'range_detail'
#endif
template< class T >
inline BOOST_DEDUCED_TYPENAME range_size<T>::type size( const T& r )
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
using namespace range_detail;
#endif
return boost_range_size( r );
}
#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
// BCB and CW are not able to overload pointer when class overloads are also available.
inline range_size<const char*>::type size( const char* r ) {
return range_detail::str_size( r );
}
inline range_size<char*>::type size( char* r ) {
return range_detail::str_size( r );
}
inline range_size<const wchar_t*>::type size( const wchar_t* r ) {
return range_detail::str_size( r );
}
inline range_size<wchar_t*>::type size( wchar_t* r ) {
return range_detail::str_size( r );
}
#endif
template< class T >
inline BOOST_DEDUCED_TYPENAME range_size<T>::type size( const T& r )
{
return boost::end( r ) - boost::begin( r );
}
} // namespace 'boost'
#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#endif

178
include/boost/range/size_type.hpp
View File

@ -16,158 +16,60 @@
#endif
#include <boost/range/config.hpp>
/*
#include <boost/range/difference_type.hpp>
namespace boost
{
namespace range_detail
{
template< class T >
struct add_unsigned;
template<>
struct add_unsigned<short>
{
typedef unsigned short type;
};
template<>
struct add_unsigned<int>
{
typedef unsigned int type;
};
template<>
struct add_unsigned<long>
{
typedef unsigned long type;
};
#ifdef BOOST_HAS_LONG_LONG
template<>
struct add_unsigned<long long>
{
typedef unsigned long long type;
};
#endif
}
template< class T >
struct range_size
{
typedef BOOST_DEDUCED_TYPENAME range_detail::add_unsigned<
BOOST_DEDUCED_TYPENAME range_difference<T>::type >::type
type;
};
}
*/
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#include <boost/range/detail/size_type.hpp>
#else
#include <boost/type_traits/remove_const.hpp>
#include <cstddef>
#include <utility>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename C >
struct range_size
namespace detail
{
typedef BOOST_DEDUCED_TYPENAME C::size_type type;
};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename C >
struct range_size
{
typedef BOOST_DEDUCED_TYPENAME C::size_type type;
};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_size< std::pair<Iterator,Iterator> >
{
typedef std::size_t type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_size< T[sz] >
{
typedef std::size_t type;
};
}
template< typename Iterator >
struct range_size< std::pair<Iterator,Iterator> >
{
typedef std::size_t type;
};
template< typename Iterator >
struct range_size< const std::pair<Iterator,Iterator> >
{
typedef std::size_t type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_size< T[sz] >
{
typedef std::size_t type;
};
template< typename T, std::size_t sz >
struct range_size< const T[sz] >
{
typedef std::size_t type;
};
//////////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////////
template<>
struct range_size< char* >
{
typedef std::size_t type;
};
template<>
struct range_size< wchar_t* >
{
typedef std::size_t type;
};
template<>
struct range_size< const char* >
{
typedef std::size_t type;
};
template<>
struct range_size< const wchar_t* >
{
typedef std::size_t type;
};
template<>
struct range_size< char* const >
{
typedef std::size_t type;
};
template<>
struct range_size< wchar_t* const >
{
typedef std::size_t type;
};
template<>
struct range_size< const char* const >
{
typedef std::size_t type;
};
template<>
struct range_size< const wchar_t* const >
{
typedef std::size_t type;
};
template< class T >
struct range_size :
detail::range_size<T>
{ };
template< class T >
struct range_size<const T > : range_size<T>
{ };
} // namespace boost
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

24
include/boost/range/sub_range.hpp
View File

@ -14,7 +14,6 @@
#include <boost/range/config.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/result_iterator.hpp>
#include <boost/range/size_type.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/assert.hpp>
@ -23,20 +22,18 @@ namespace boost
{
template< class ForwardRange >
class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type >
class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
{
typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type iterator_t;
typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;
typedef iterator_range< iterator_t > base;
typedef BOOST_DEDUCED_TYPENAME base::impl impl;
public:
typedef BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type value_type;
typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type iterator;
typedef BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type const_iterator;
typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator;
typedef BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type const_iterator;
typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type difference_type;
typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type size_type;
typedef BOOST_DEDUCED_TYPENAME base::reference reference;
typedef BOOST_DEDUCED_TYPENAME iterator_reference<const_iterator>::type const_reference;
public:
sub_range() : base()
@ -111,32 +108,32 @@ namespace boost
public: // convenience
reference front()
value_type& front()
{
return base::front();
}
const_reference front() const
const value_type& front() const
{
return base::front();
}
reference back()
value_type& back()
{
return base::back();
}
const_reference back() const
const value_type& back() const
{
return base::back();
}
reference operator[]( size_type sz )
value_type& operator[]( size_type sz )
{
return base::operator[](sz);
}
const_reference operator[]( size_type sz ) const
const value_type& operator[]( size_type sz ) const
{
return base::operator[](sz);
}
@ -168,3 +165,4 @@ namespace boost
} // namespace 'boost'
#endif

124
include/boost/range/value_type.hpp
View File

@ -18,129 +18,17 @@
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#include <boost/range/detail/value_type.hpp>
#else
//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
//#include <boost/range/detail/value_type.hpp>
//#else
#include <boost/iterator/iterator_traits.hpp>
namespace boost
{
template< class T >
struct range_value
{
typedef BOOST_DEDUCED_TYPENAME iterator_value<
BOOST_DEDUCED_TYPENAME range_iterator<T>::type >::type
type;
};
template< class T >
struct range_value : iterator_value< typename range_iterator<T>::type >
{ };
}
/*
#include <cstddef>
#include <utility>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename C >
struct range_value
{
typedef BOOST_DEDUCED_TYPENAME C::value_type type;
};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_value< std::pair<Iterator,Iterator> >
{
typedef BOOST_DEDUCED_TYPENAME
iterator_value<Iterator>::type type;
};
template< typename Iterator >
struct range_value< const std::pair<Iterator,Iterator> >
{
typedef BOOST_DEDUCED_TYPENAME
iterator_value<Iterator>::type type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_value< T[sz] >
{
typedef T type;
};
template< typename T, std::size_t sz >
struct range_value< const T[sz] >
{
typedef const T type;
};
//////////////////////////////////////////////////////////////////////////
// string
//////////////////////////////////////////////////////////////////////////
template<>
struct range_value< char* >
{
typedef char type;
};
template<>
struct range_value< wchar_t* >
{
typedef wchar_t type;
};
template<>
struct range_value< const char* >
{
typedef const char type;
};
template<>
struct range_value< const wchar_t* >
{
typedef const wchar_t type;
};
template<>
struct range_value< char* const >
{
typedef char type;
};
template<>
struct range_value< wchar_t* const >
{
typedef wchar_t type;
};
template<>
struct range_value< const char* const >
{
typedef const char type;
};
template<>
struct range_value< const wchar_t* const >
{
typedef const wchar_t type;
};
} // namespace boost
*/
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif