Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/range')
32 files changed, 3258 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/range/as_literal.hpp b/3rdParty/Boost/src/boost/range/as_literal.hpp new file mode 100644 index 0000000..2f04ca8 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/as_literal.hpp @@ -0,0 +1,127 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_AS_LITERAL_HPP +#define BOOST_RANGE_AS_LITERAL_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +#include <boost/range/detail/as_literal.hpp> +#else + +#include <boost/range/iterator_range.hpp> +#include <boost/range/detail/str_types.hpp> + +#include <boost/detail/workaround.hpp> + +#include <cstring> +#ifndef BOOST_NO_CWCHAR +#include <cwchar> +#endif + +namespace boost +{ + namespace range_detail + { + inline std::size_t length( const char* s ) + { + return strlen( s ); + } + +#ifndef BOOST_NO_CWCHAR + inline std::size_t length( const wchar_t* s ) + { + return wcslen( s ); + } +#endif + + // + // Remark: the compiler cannot choose between T* and T[sz] + // overloads, so we must put the T* internal to the + // unconstrained version. + // + + inline bool is_char_ptr( char* ) + { + return true; + } + + inline bool is_char_ptr( const char* ) + { + return true; + } + +#ifndef BOOST_NO_CWCHAR + inline bool is_char_ptr( wchar_t* ) + { + return true; + } + + inline bool is_char_ptr( const wchar_t* ) + { + return true; + } +#endif + + template< class T > + inline long is_char_ptr( T /* r */ ) + { + return 0L; + } + + template< class T > + inline iterator_range<T*> + make_range( T* const r, bool ) + { + return iterator_range<T*>( r, r + length(r) ); + } + + template< class T > + inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type> + make_range( T& r, long ) + { + return boost::make_iterator_range( r ); + } + + } + + template< class Range > + inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type> + as_literal( Range& r ) + { + return range_detail::make_range( r, range_detail::is_char_ptr(r) ); + } + + template< class Range > + inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type> + as_literal( const Range& r ) + { + return range_detail::make_range( r, range_detail::is_char_ptr(r) ); + } + + template< class Char, std::size_t sz > + inline iterator_range<Char*> as_literal( Char (&arr)[sz] ) + { + return range_detail::make_range( arr, range_detail::is_char_ptr(arr) ); + } + + template< class Char, std::size_t sz > + inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] ) + { + return range_detail::make_range( arr, range_detail::is_char_ptr(arr) ); + } +} + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +#endif diff --git a/3rdParty/Boost/src/boost/range/begin.hpp b/3rdParty/Boost/src/boost/range/begin.hpp new file mode 100644 index 0000000..a4a5e10 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/begin.hpp @@ -0,0 +1,132 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_BEGIN_HPP +#define BOOST_RANGE_BEGIN_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/config.hpp> + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +#include <boost/range/detail/begin.hpp> +#else + +#include <boost/range/iterator.hpp> + +namespace boost +{ + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ + !BOOST_WORKAROUND(__GNUC__, < 3) \ + /**/ +namespace range_detail +{ +#endif + + ////////////////////////////////////////////////////////////////////// + // primary template + ////////////////////////////////////////////////////////////////////// + + template< typename C > + inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type + range_begin( C& c ) + { + // + // If you get a compile-error here, it is most likely because + // you have not implemented range_begin() properly in + // the namespace of C + // + return c.begin(); + } + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template< typename Iterator > + inline Iterator range_begin( const std::pair<Iterator,Iterator>& p ) + { + return p.first; + } + + template< typename Iterator > + inline Iterator range_begin( std::pair<Iterator,Iterator>& p ) + { + return p.first; + } + + ////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////// + + // + // May this be discarded? Or is it needed for bad compilers? + // + template< typename T, std::size_t sz > + inline const T* range_begin( const T (&a)[sz] ) + { + return a; + } + + template< typename T, std::size_t sz > + inline T* range_begin( T (&a)[sz] ) + { + return a; + } + + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ + !BOOST_WORKAROUND(__GNUC__, < 3) \ + /**/ +} // namespace 'range_detail' +#endif + + +template< class T > +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 range_begin( r ); +} + +template< class T > +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 range_begin( r ); +} + +} // namespace boost + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +namespace boost +{ + template< class T > + inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type + const_begin( const T& r ) + { + return boost::begin( r ); + } +} + +#endif + diff --git a/3rdParty/Boost/src/boost/range/config.hpp b/3rdParty/Boost/src/boost/range/config.hpp new file mode 100644 index 0000000..4e7fb24 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/config.hpp @@ -0,0 +1,54 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_CONFIG_HPP +#define BOOST_RANGE_CONFIG_HPP + +#include <boost/detail/workaround.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/config.hpp> + +#ifdef BOOST_RANGE_DEDUCED_TYPENAME +#error "macro already defined!" +#endif + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +# define BOOST_RANGE_DEDUCED_TYPENAME typename +#else +# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS) +# define BOOST_RANGE_DEDUCED_TYPENAME typename +# else +# define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME +# endif +#endif + +#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT +#error "macro already defined!" +#endif + +#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) +#define BOOST_RANGE_NO_ARRAY_SUPPORT 1 +#endif + +#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT +#define BOOST_RANGE_ARRAY_REF() (boost_range_array) +#define BOOST_RANGE_NO_STATIC_ASSERT +#else +#define BOOST_RANGE_ARRAY_REF() (&boost_range_array) +#endif + + + +#endif + diff --git a/3rdParty/Boost/src/boost/range/const_iterator.hpp b/3rdParty/Boost/src/boost/range/const_iterator.hpp new file mode 100644 index 0000000..195f9d4 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/const_iterator.hpp @@ -0,0 +1,64 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_CONST_ITERATOR_HPP +#define BOOST_RANGE_CONST_ITERATOR_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/config.hpp> + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +#include <boost/range/detail/const_iterator.hpp> +#else + +#include <boost/type_traits/remove_const.hpp> +#include <cstddef> +#include <utility> + +namespace boost +{ + ////////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////////// + + template< typename C > + struct range_const_iterator + { + typedef BOOST_DEDUCED_TYPENAME C::const_iterator type; + }; + + ////////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////////// + + template< typename Iterator > + struct range_const_iterator< std::pair<Iterator,Iterator> > + { + typedef Iterator type; + }; + + ////////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////////// + + template< typename T, std::size_t sz > + struct range_const_iterator< T[sz] > + { + typedef const T* type; + }; + +} // namespace boost + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/as_literal.hpp b/3rdParty/Boost/src/boost/range/detail/as_literal.hpp new file mode 100644 index 0000000..0bd9a15 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/as_literal.hpp @@ -0,0 +1,33 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP +#define BOOST_RANGE_DETAIL_AS_LITERAL_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/detail/detail_str.hpp> +#include <boost/range/iterator_range.hpp> + +namespace boost +{ + template< class Range > + inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type> + as_literal( Range& r ) + { + return ::boost::make_iterator_range( ::boost::range_detail::str_begin(r), + ::boost::range_detail::str_end(r) ); + } + +} + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/begin.hpp b/3rdParty/Boost/src/boost/range/detail/begin.hpp new file mode 100644 index 0000000..06c2561 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/begin.hpp @@ -0,0 +1,92 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_BEGIN_HPP +#define BOOST_RANGE_DETAIL_BEGIN_HPP + +#include <boost/config.hpp> // BOOST_MSVC +#include <boost/detail/workaround.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/detail/common.hpp> +#if BOOST_WORKAROUND(BOOST_MSVC, < 1310) +# include <boost/range/value_type.hpp> +#endif + +namespace boost +{ + + namespace range_detail + { + template< typename T > + struct range_begin; + + ////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_begin<std_container_> + { + template< typename C > + static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type fun( C& c ) + { + return c.begin(); + }; + }; + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_begin<std_pair_> + { + template< typename P > + static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type fun( const P& p ) + { + return p.first; + } + }; + + ////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_begin<array_> + { + #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) + template< typename T, std::size_t sz > + static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] ) + { + return boost_range_array; + } + #else + template<typename T> + static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t) + { + return t; + } + #endif + }; + + } // namespace 'range_detail' + + template< typename C > + 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 ); + } + +} // namespace 'boost' + + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/common.hpp b/3rdParty/Boost/src/boost/range/detail/common.hpp new file mode 100644 index 0000000..f7539f5 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/common.hpp @@ -0,0 +1,117 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_COMMON_HPP +#define BOOST_RANGE_DETAIL_COMMON_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/config.hpp> +#include <boost/range/detail/sfinae.hpp> +#include <boost/type_traits/is_void.hpp> +#include <boost/type_traits/detail/ice_or.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/int.hpp> +#include <cstddef> + +////////////////////////////////////////////////////////////////////////////// +// missing partial specialization workaround. +////////////////////////////////////////////////////////////////////////////// + +namespace boost +{ + namespace range_detail + { + // 1 = std containers + // 2 = std::pair + // 3 = const std::pair + // 4 = array + // 5 = const array + // 6 = char array + // 7 = wchar_t array + // 8 = char* + // 9 = const char* + // 10 = whar_t* + // 11 = const wchar_t* + // 12 = string + + typedef mpl::int_<1>::type std_container_; + typedef mpl::int_<2>::type std_pair_; + typedef mpl::int_<3>::type const_std_pair_; + typedef mpl::int_<4>::type array_; + typedef mpl::int_<5>::type const_array_; + typedef mpl::int_<6>::type char_array_; + typedef mpl::int_<7>::type wchar_t_array_; + typedef mpl::int_<8>::type char_ptr_; + typedef mpl::int_<9>::type const_char_ptr_; + typedef mpl::int_<10>::type wchar_t_ptr_; + typedef mpl::int_<11>::type const_wchar_t_ptr_; + typedef mpl::int_<12>::type string_; + + template< typename C > + struct range_helper + { + static C* c; + static C ptr; + + BOOST_STATIC_CONSTANT( bool, is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) ); + BOOST_STATIC_CONSTANT( bool, is_string_ = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value )); + BOOST_STATIC_CONSTANT( bool, is_array_ = boost::is_array<C>::value ); + + }; + + template< typename C > + class range + { + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_, + boost::range_detail::std_pair_, + void >::type pair_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_, + boost::range_detail::array_, + pair_t >::type array_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_, + boost::range_detail::string_, + array_t >::type string_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_, + boost::range_detail::const_char_ptr_, + string_t >::type const_char_ptr_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_, + boost::range_detail::char_ptr_, + const_char_ptr_t >::type char_ptr_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_, + boost::range_detail::const_wchar_t_ptr_, + char_ptr_t >::type const_wchar_ptr_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_, + boost::range_detail::wchar_t_ptr_, + const_wchar_ptr_t >::type wchar_ptr_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_, + boost::range_detail::wchar_t_array_, + wchar_ptr_t >::type wchar_array_t; + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_, + boost::range_detail::char_array_, + wchar_array_t >::type char_array_t; + public: + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::is_void<char_array_t>::value, + boost::range_detail::std_container_, + char_array_t >::type type; + }; // class 'range' + } +} + +#endif + diff --git a/3rdParty/Boost/src/boost/range/detail/const_iterator.hpp b/3rdParty/Boost/src/boost/range/detail/const_iterator.hpp new file mode 100644 index 0000000..e5cb34a --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/const_iterator.hpp @@ -0,0 +1,71 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP +#define BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP + +#include <boost/range/detail/common.hpp> +#include <boost/range/detail/remove_extent.hpp> + +////////////////////////////////////////////////////////////////////////////// +// missing partial specialization workaround. +////////////////////////////////////////////////////////////////////////////// + +namespace boost +{ + namespace range_detail + { + template< typename T > + struct range_const_iterator_; + + template<> + struct range_const_iterator_<std_container_> + { + template< typename C > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME C::const_iterator type; + }; + }; + + template<> + struct range_const_iterator_<std_pair_> + { + template< typename P > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type; + }; + }; + + + template<> + struct range_const_iterator_<array_> + { + template< typename T > + struct pts + { + typedef const BOOST_RANGE_DEDUCED_TYPENAME + remove_extent<T>::type* type; + }; + }; + } + + template< typename C > + class range_const_iterator + { + typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type; + public: + typedef BOOST_DEDUCED_TYPENAME range_detail::range_const_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; + }; + +} + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/detail_str.hpp b/3rdParty/Boost/src/boost/range/detail/detail_str.hpp new file mode 100644 index 0000000..d5ad5b3 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/detail_str.hpp @@ -0,0 +1,376 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_DETAIL_STR_HPP +#define BOOST_RANGE_DETAIL_DETAIL_STR_HPP + +#include <boost/config.hpp> // BOOST_MSVC +#include <boost/range/iterator.hpp> + +namespace boost +{ + + namespace range_detail + { + // + // iterator + // + + 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; + }; + }; + + + // + // const iterator + // + + 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; + }; + }; + } +} + +#include <boost/range/detail/begin.hpp> +#include <boost/range/detail/end.hpp> +#include <boost/range/detail/size_type> +#include <boost/range/detail/value_type> +#include <boost/range/detail/common.hpp> + +namespace boost +{ + + namespace range_detail + { + // + // str_begin() + // + 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; + } + }; + + template< typename C > + inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type + str_begin( C& c ) + { + return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME + range_detail::range<C>::type >::fun( c ); + } + + // + // str_end() + // + + 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 ); + } + }; + + 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 ); + } + }; + + template< typename C > + inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type + str_end( C& c ) + { + return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME + range_detail::range<C>::type >::fun( c ); + } + + // + // size_type + // + + 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; + }; + }; + + // + // value_type + // + + 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; + }; + }; + + } // namespace 'range_detail' + +} // namespace 'boost' + + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/end.hpp b/3rdParty/Boost/src/boost/range/detail/end.hpp new file mode 100644 index 0000000..d6a7368 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/end.hpp @@ -0,0 +1,98 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_END_HPP +#define BOOST_RANGE_DETAIL_END_HPP + +#include <boost/config.hpp> // BOOST_MSVC +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +# include <boost/range/detail/vc6/end.hpp> +#else +# include <boost/range/detail/implementation_help.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> +# endif + +namespace boost +{ + namespace range_detail + { + template< typename T > + struct range_end; + + ////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_end<std_container_> + { + template< typename C > + static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type + fun( C& c ) + { + return c.end(); + }; + }; + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_end<std_pair_> + { + template< typename P > + static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type + fun( const P& p ) + { + return p.second; + } + }; + + ////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_end<array_> + { + #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310) + 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 ); + } + #else + template<typename T> + static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t) + { + return t + remove_extent<T>::size; + } + #endif + }; + + } // namespace 'range_detail' + + template< typename C > + 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 ); + } + +} // namespace 'boost' + +# endif // VC6 +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp b/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp new file mode 100644 index 0000000..ca12fa4 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/implementation_help.hpp @@ -0,0 +1,103 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP +#define BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP + +#include <boost/range/config.hpp> +#include <boost/range/detail/common.hpp> +#include <boost/type_traits/is_same.hpp> +#include <cstddef> +#include <string.h> + +#ifndef BOOST_NO_CWCHAR +#include <wchar.h> +#endif + +namespace boost +{ + namespace range_detail + { + template <typename T> + inline void boost_range_silence_warning( const T& ) { } + + ///////////////////////////////////////////////////////////////////// + // end() help + ///////////////////////////////////////////////////////////////////// + + inline const char* str_end( const char* s, const char* ) + { + return s + strlen( s ); + } + +#ifndef BOOST_NO_CWCHAR + inline const wchar_t* str_end( const wchar_t* s, const wchar_t* ) + { + return s + wcslen( s ); + } +#else + inline const wchar_t* str_end( const wchar_t* s, const wchar_t* ) + { + if( s == 0 || s[0] == 0 ) + return s; + while( *++s != 0 ) + ; + return s; + } +#endif + + template< class Char > + inline Char* str_end( Char* s ) + { + return const_cast<Char*>( str_end( s, s ) ); + } + + template< class T, std::size_t sz > + inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] ) + { + return boost_range_array + sz; + } + + template< class T, std::size_t sz > + inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] ) + { + return boost_range_array + sz; + } + + ///////////////////////////////////////////////////////////////////// + // size() help + ///////////////////////////////////////////////////////////////////// + + template< class Char > + inline std::size_t str_size( const Char* const& s ) + { + return str_end( s ) - s; + } + + template< class T, std::size_t sz > + inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz] ) + { + boost_range_silence_warning( boost_range_array ); + return sz; + } + + template< class T, std::size_t sz > + inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz] ) + { + boost_range_silence_warning( boost_range_array ); + return sz; + } + + } // namespace 'range_detail' + +} // namespace 'boost' + + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/iterator.hpp b/3rdParty/Boost/src/boost/range/detail/iterator.hpp new file mode 100644 index 0000000..58346d4 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/iterator.hpp @@ -0,0 +1,78 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_ITERATOR_HPP +#define BOOST_RANGE_DETAIL_ITERATOR_HPP + +#include <boost/range/detail/common.hpp> +#include <boost/range/detail/remove_extent.hpp> + +#include <boost/static_assert.hpp> + +////////////////////////////////////////////////////////////////////////////// +// missing partial specialization workaround. +////////////////////////////////////////////////////////////////////////////// + +namespace boost +{ + namespace range_detail + { + template< typename T > + struct range_iterator_ { + template< typename C > + struct pts + { + typedef int type; + }; + }; + + template<> + struct range_iterator_<std_container_> + { + template< typename C > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME C::iterator type; + }; + }; + + template<> + struct range_iterator_<std_pair_> + { + template< typename P > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type; + }; + }; + + template<> + struct range_iterator_<array_> + { + template< typename T > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME + remove_extent<T>::type* type; + }; + }; + + } + + template< typename C > + class range_mutable_iterator + { + typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type; + public: + typedef typename range_detail::range_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; + }; +} + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/remove_extent.hpp b/3rdParty/Boost/src/boost/range/detail/remove_extent.hpp new file mode 100644 index 0000000..68e4597 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/remove_extent.hpp @@ -0,0 +1,157 @@ +// Boost.Range library +// +// Copyright Jonathan Turkanis 2005. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + + +#ifndef BOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP +#define BOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP + +#include <boost/config.hpp> // MSVC, NO_INTRINSIC_WCHAR_T, put size_t in std. +#include <cstddef> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_same.hpp> + +namespace boost +{ + namespace range_detail + { + + template< typename Case1 = mpl::true_, + typename Type1 = mpl::void_, + typename Case2 = mpl::true_, + typename Type2 = mpl::void_, + typename Case3 = mpl::true_, + typename Type3 = mpl::void_, + typename Case4 = mpl::true_, + typename Type4 = mpl::void_, + typename Case5 = mpl::true_, + typename Type5 = mpl::void_, + typename Case6 = mpl::true_, + typename Type6 = mpl::void_, + typename Case7 = mpl::true_, + typename Type7 = mpl::void_, + typename Case8 = mpl::true_, + typename Type8 = mpl::void_, + typename Case9 = mpl::true_, + typename Type9 = mpl::void_, + typename Case10 = mpl::true_, + typename Type10 = mpl::void_, + typename Case11 = mpl::true_, + typename Type11 = mpl::void_, + typename Case12 = mpl::true_, + typename Type12 = mpl::void_, + typename Case13 = mpl::true_, + typename Type13 = mpl::void_, + typename Case14 = mpl::true_, + typename Type14 = mpl::void_, + typename Case15 = mpl::true_, + typename Type15 = mpl::void_, + typename Case16 = mpl::true_, + typename Type16 = mpl::void_, + typename Case17 = mpl::true_, + typename Type17 = mpl::void_, + typename Case18 = mpl::true_, + typename Type18 = mpl::void_, + typename Case19 = mpl::true_, + typename Type19 = mpl::void_, + typename Case20 = mpl::true_, + typename Type20 = mpl::void_> + struct select { + typedef typename + mpl::eval_if< + Case1, mpl::identity<Type1>, mpl::eval_if< + Case2, mpl::identity<Type2>, mpl::eval_if< + Case3, mpl::identity<Type3>, mpl::eval_if< + Case4, mpl::identity<Type4>, mpl::eval_if< + Case5, mpl::identity<Type5>, mpl::eval_if< + Case6, mpl::identity<Type6>, mpl::eval_if< + Case7, mpl::identity<Type7>, mpl::eval_if< + Case8, mpl::identity<Type8>, mpl::eval_if< + Case9, mpl::identity<Type9>, mpl::if_< + Case10, Type10, mpl::void_ > > > > > > > > > + >::type result1; + typedef typename + mpl::eval_if< + Case11, mpl::identity<Type11>, mpl::eval_if< + Case12, mpl::identity<Type12>, mpl::eval_if< + Case13, mpl::identity<Type13>, mpl::eval_if< + Case14, mpl::identity<Type14>, mpl::eval_if< + Case15, mpl::identity<Type15>, mpl::eval_if< + Case16, mpl::identity<Type16>, mpl::eval_if< + Case17, mpl::identity<Type17>, mpl::eval_if< + Case18, mpl::identity<Type18>, mpl::eval_if< + Case19, mpl::identity<Type19>, mpl::if_< + Case20, Type20, mpl::void_ > > > > > > > > > + > result2; + typedef typename + mpl::eval_if< + is_same<result1, mpl::void_>, + result2, + mpl::identity<result1> + >::type type; + }; + + template<typename T> + struct remove_extent { + static T* ar; + BOOST_STATIC_CONSTANT(std::size_t, size = sizeof(*ar) / sizeof((*ar)[0])); + + typedef typename + select< + is_same<T, bool[size]>, bool, + is_same<T, char[size]>, char, + is_same<T, signed char[size]>, signed char, + is_same<T, unsigned char[size]>, unsigned char, + #ifndef BOOST_NO_INTRINSIC_WCHAR_T + is_same<T, wchar_t[size]>, wchar_t, + #endif + is_same<T, short[size]>, short, + is_same<T, unsigned short[size]>, unsigned short, + is_same<T, int[size]>, int, + is_same<T, unsigned int[size]>, unsigned int, + is_same<T, long[size]>, long, + is_same<T, unsigned long[size]>, unsigned long, + is_same<T, float[size]>, float, + is_same<T, double[size]>, double, + is_same<T, long double[size]>, long double + >::type result1; + typedef typename + select< + is_same<T, const bool[size]>, const bool, + is_same<T, const char[size]>, const char, + is_same<T, const signed char[size]>, const signed char, + is_same<T, const unsigned char[size]>, const unsigned char, + #ifndef BOOST_NO_INTRINSIC_WCHAR_T + is_same<T, const wchar_t[size]>, const wchar_t, + #endif + is_same<T, const short[size]>, const short, + is_same<T, const unsigned short[size]>, const unsigned short, + is_same<T, const int[size]>, const int, + is_same<T, const unsigned int[size]>, const unsigned int, + is_same<T, const long[size]>, const long, + is_same<T, const unsigned long[size]>, const unsigned long, + is_same<T, const float[size]>, const float, + is_same<T, const double[size]>, const double, + is_same<T, const long double[size]>, const long double + > result2; + typedef typename + mpl::eval_if< + is_same<result1, mpl::void_>, + result2, + mpl::identity<result1> + >::type type; + }; + + } // namespace 'range_detail' + +} // namespace 'boost' + + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/sfinae.hpp b/3rdParty/Boost/src/boost/range/detail/sfinae.hpp new file mode 100644 index 0000000..5b2c61e --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/sfinae.hpp @@ -0,0 +1,77 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_SFINAE_HPP +#define BOOST_RANGE_DETAIL_SFINAE_HPP + +#include <boost/range/config.hpp> +#include <boost/type_traits/is_array.hpp> +#include <boost/type_traits/detail/yes_no_type.hpp> +#include <utility> + + +namespace boost +{ + namespace range_detail + { + using type_traits::yes_type; + using type_traits::no_type; + + ////////////////////////////////////////////////////////////////////// + // string + ////////////////////////////////////////////////////////////////////// + + yes_type is_string_impl( const char* const ); + yes_type is_string_impl( const wchar_t* const ); + no_type is_string_impl( ... ); + + template< std::size_t sz > + yes_type is_char_array_impl( char BOOST_RANGE_ARRAY_REF()[sz] ); + template< std::size_t sz > + yes_type is_char_array_impl( const char BOOST_RANGE_ARRAY_REF()[sz] ); + no_type is_char_array_impl( ... ); + + template< std::size_t sz > + yes_type is_wchar_t_array_impl( wchar_t BOOST_RANGE_ARRAY_REF()[sz] ); + template< std::size_t sz > + yes_type is_wchar_t_array_impl( const wchar_t BOOST_RANGE_ARRAY_REF()[sz] ); + no_type is_wchar_t_array_impl( ... ); + + yes_type is_char_ptr_impl( char* const ); + no_type is_char_ptr_impl( ... ); + + yes_type is_const_char_ptr_impl( const char* const ); + no_type is_const_char_ptr_impl( ... ); + + yes_type is_wchar_t_ptr_impl( wchar_t* const ); + no_type is_wchar_t_ptr_impl( ... ); + + yes_type is_const_wchar_t_ptr_impl( const wchar_t* const ); + no_type is_const_wchar_t_ptr_impl( ... ); + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template< typename Iterator > + yes_type is_pair_impl( const std::pair<Iterator,Iterator>* ); + no_type is_pair_impl( ... ); + + ////////////////////////////////////////////////////////////////////// + // tags + ////////////////////////////////////////////////////////////////////// + + struct char_or_wchar_t_array_tag {}; + + } // namespace 'range_detail' + +} // namespace 'boost' + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/size_type.hpp b/3rdParty/Boost/src/boost/range/detail/size_type.hpp new file mode 100644 index 0000000..ec49f4d --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/size_type.hpp @@ -0,0 +1,70 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_SIZE_TYPE_HPP +#define BOOST_RANGE_DETAIL_SIZE_TYPE_HPP + +#include <boost/range/detail/common.hpp> + +////////////////////////////////////////////////////////////////////////////// +// missing partial specialization workaround. +////////////////////////////////////////////////////////////////////////////// + +namespace boost +{ + namespace range_detail + { + template< typename T > + struct range_size_type_; + + template<> + struct range_size_type_<std_container_> + { + template< typename C > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME C::size_type type; + }; + }; + + template<> + struct range_size_type_<std_pair_> + { + template< typename P > + struct pts + { + typedef std::size_t type; + }; + }; + + template<> + struct range_size_type_<array_> + { + template< typename A > + struct pts + { + typedef std::size_t type; + }; + }; + + + } + + template< typename C > + class range_size + { + typedef typename range_detail::range<C>::type c_type; + public: + typedef typename range_detail::range_size_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; + }; +} + +#endif + diff --git a/3rdParty/Boost/src/boost/range/detail/str_types.hpp b/3rdParty/Boost/src/boost/range/detail/str_types.hpp new file mode 100644 index 0000000..f8cab19 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/str_types.hpp @@ -0,0 +1,38 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_STR_TYPES_HPP +#define BOOST_RANGE_DETAIL_STR_TYPES_HPP + +#include <boost/range/size_type.hpp> +#include <boost/range/iterator.hpp> + +namespace boost +{ + template< class T > + struct range_mutable_iterator<T*> + { + typedef T* type; + }; + + template< class T > + struct range_const_iterator<T*> + { + typedef const T* type; + }; + + template< class T > + struct range_size<T*> + { + typedef std::size_t type; + }; +} + +#endif diff --git a/3rdParty/Boost/src/boost/range/detail/vc6/end.hpp b/3rdParty/Boost/src/boost/range/detail/vc6/end.hpp new file mode 100644 index 0000000..4f76af5 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/detail/vc6/end.hpp @@ -0,0 +1,170 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DETAIL_VC6_END_HPP +#define BOOST_RANGE_DETAIL_VC6_END_HPP + +#include <boost/range/detail/implementation_help.hpp> +#include <boost/range/detail/implementation_help.hpp> +#include <boost/range/result_iterator.hpp> +#include <boost/range/detail/common.hpp> +#include <boost/range/detail/remove_extent.hpp> + +namespace boost +{ + namespace range_detail + { + template< typename T > + struct range_end; + + ////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_end<std_container_> + { + template< typename C > + struct inner { + static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type + fun( C& c ) + { + return c.end(); + }; + }; + }; + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_end<std_pair_> + { + template< typename P > + struct inner { + static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type + fun( const P& p ) + { + return p.second; + } + }; + }; + + ////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_end<array_> + { + template< typename T > + struct inner { + static BOOST_DEDUCED_TYPENAME remove_extent<T>::type* + fun(T& t) + { + return t + remove_extent<T>::size; + } + }; + }; + + + template<> + struct range_end<char_array_> + { + template< typename T > + struct inner { + static BOOST_DEDUCED_TYPENAME remove_extent<T>::type* + fun(T& t) + { + return t + remove_extent<T>::size; + } + }; + }; + + template<> + struct range_end<wchar_t_array_> + { + template< typename T > + struct inner { + static BOOST_DEDUCED_TYPENAME remove_extent<T>::type* + fun(T& t) + { + return t + remove_extent<T>::size; + } + }; + }; + + ////////////////////////////////////////////////////////////////////// + // string + ////////////////////////////////////////////////////////////////////// + + template<> + struct range_end<char_ptr_> + { + template< typename T > + struct inner { + static char* fun( char* s ) + { + return boost::range_detail::str_end( s ); + } + }; + }; + + template<> + struct range_end<const_char_ptr_> + { + template< typename T > + struct inner { + static const char* fun( const char* s ) + { + return boost::range_detail::str_end( s ); + } + }; + }; + + template<> + struct range_end<wchar_t_ptr_> + { + template< typename T > + struct inner { + static wchar_t* fun( wchar_t* s ) + { + return boost::range_detail::str_end( s ); + } + }; + }; + + + template<> + struct range_end<const_wchar_t_ptr_> + { + template< typename T > + struct inner { + static const wchar_t* fun( const wchar_t* s ) + { + return boost::range_detail::str_end( s ); + } + }; + }; + + } // namespace 'range_detail' + + template< typename C > + inline BOOST_DEDUCED_TYPENAME range_result_iterator<C>::type + end( C& c ) + { + return range_detail::range_end<range_detail::range<C>::type>::inner<C>::fun( c ); + } + +} // namespace 'boost' + + +#endif diff --git a/3rdParty/Boost/src/boost/range/difference_type.hpp b/3rdParty/Boost/src/boost/range/difference_type.hpp new file mode 100644 index 0000000..164288f --- /dev/null +++ b/3rdParty/Boost/src/boost/range/difference_type.hpp @@ -0,0 +1,29 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DIFFERENCE_TYPE_HPP +#define BOOST_RANGE_DIFFERENCE_TYPE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/config.hpp> +#include <boost/range/iterator.hpp> +#include <boost/iterator/iterator_traits.hpp> + +namespace boost +{ + template< class T > + struct range_difference : iterator_difference< typename range_iterator<T>::type > + { }; +} + +#endif diff --git a/3rdParty/Boost/src/boost/range/distance.hpp b/3rdParty/Boost/src/boost/range/distance.hpp new file mode 100644 index 0000000..42a106d --- /dev/null +++ b/3rdParty/Boost/src/boost/range/distance.hpp @@ -0,0 +1,34 @@ +// Boost.Range library +// +// 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_DISTANCE_HPP +#define BOOST_RANGE_DISTANCE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/difference_type.hpp> + +namespace boost +{ + + template< class T > + inline BOOST_DEDUCED_TYPENAME range_difference<T>::type + distance( const T& r ) + { + return std::distance( boost::begin( r ), boost::end( r ) ); + } + +} // namespace 'boost' + +#endif diff --git a/3rdParty/Boost/src/boost/range/empty.hpp b/3rdParty/Boost/src/boost/range/empty.hpp new file mode 100644 index 0000000..78c4e85 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/empty.hpp @@ -0,0 +1,34 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_EMPTY_HPP +#define BOOST_RANGE_EMPTY_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/config.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> + +namespace boost +{ + + template< class T > + inline bool empty( const T& r ) + { + return boost::begin( r ) == boost::end( r ); + } + +} // namepace 'boost' + + +#endif diff --git a/3rdParty/Boost/src/boost/range/end.hpp b/3rdParty/Boost/src/boost/range/end.hpp new file mode 100644 index 0000000..3063c02 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/end.hpp @@ -0,0 +1,131 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_END_HPP +#define BOOST_RANGE_END_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/config.hpp> + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +#include <boost/range/detail/end.hpp> +#else + +#include <boost/range/detail/implementation_help.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/const_iterator.hpp> + +namespace boost +{ + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ + !BOOST_WORKAROUND(__GNUC__, < 3) \ + /**/ +namespace range_detail +{ +#endif + + ////////////////////////////////////////////////////////////////////// + // primary template + ////////////////////////////////////////////////////////////////////// + template< typename C > + inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type + range_end( C& c ) + { + // + // If you get a compile-error here, it is most likely because + // you have not implemented range_begin() properly in + // the namespace of C + // + return c.end(); + } + + ////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////// + + template< typename Iterator > + inline Iterator range_end( const std::pair<Iterator,Iterator>& p ) + { + return p.second; + } + + template< typename Iterator > + inline Iterator range_end( std::pair<Iterator,Iterator>& p ) + { + return p.second; + } + + ////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////// + + template< typename T, std::size_t sz > + inline const T* range_end( const T (&a)[sz] ) + { + return range_detail::array_end<T,sz>( a ); + } + + template< typename T, std::size_t sz > + inline T* range_end( T (&a)[sz] ) + { + return range_detail::array_end<T,sz>( a ); + } + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ + !BOOST_WORKAROUND(__GNUC__, < 3) \ + /**/ +} // namespace 'range_detail' +#endif + +template< class T > +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 range_end( r ); +} + +template< class T > +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 range_end( r ); +} + +} // namespace 'boost' + + + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + + +namespace boost +{ + template< class T > + inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type + const_end( const T& r ) + { + return boost::end( r ); + } +} + +#endif + diff --git a/3rdParty/Boost/src/boost/range/functions.hpp b/3rdParty/Boost/src/boost/range/functions.hpp new file mode 100644 index 0000000..b8b8608 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/functions.hpp @@ -0,0 +1,27 @@ +// Boost.Range library +// +// 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_FUNCTIONS_HPP +#define BOOST_RANGE_FUNCTIONS_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#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 + diff --git a/3rdParty/Boost/src/boost/range/iterator.hpp b/3rdParty/Boost/src/boost/range/iterator.hpp new file mode 100644 index 0000000..21798c5 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/iterator.hpp @@ -0,0 +1,72 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_ITERATOR_HPP +#define BOOST_RANGE_ITERATOR_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include <boost/range/config.hpp> +#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 +{ + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + + namespace range_detail_vc7_1 + { + template< typename C, typename Sig = void(C) > + struct range_iterator + { + 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; + }; + + template< typename C, typename T > + struct range_iterator< C, void(T[]) > + { + typedef T* type; + }; + } + +#endif + + template< typename C > + struct range_iterator + { +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + + typedef BOOST_RANGE_DEDUCED_TYPENAME + range_detail_vc7_1::range_iterator<C>::type type; + +#else + + 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; + +#endif + }; + +} // namespace boost + +//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif diff --git a/3rdParty/Boost/src/boost/range/iterator_range.hpp b/3rdParty/Boost/src/boost/range/iterator_range.hpp new file mode 100644 index 0000000..d118224 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/iterator_range.hpp @@ -0,0 +1,659 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen & Pavol Droba 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_ITERATOR_RANGE_HPP +#define BOOST_RANGE_ITERATOR_RANGE_HPP + +#include <boost/config.hpp> // Define __STL_CONFIG_H, if appropriate. +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) + #pragma warning( push ) + #pragma warning( disable : 4996 ) +#endif + +// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for Cray X1 patch. +#ifndef BOOST_OLD_IOSTREAMS +# if defined(__STL_CONFIG_H) && \ + !defined (__STL_USE_NEW_IOSTREAMS) && !defined(__crayx1) \ + /**/ +# define BOOST_OLD_IOSTREAMS +# endif +#endif // #ifndef BOOST_OLD_IOSTREAMS + +#include <boost/assert.hpp> +#include <boost/iterator/iterator_traits.hpp> +#include <boost/type_traits/is_abstract.hpp> +#include <boost/range/functions.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/difference_type.hpp> +#include <boost/utility/enable_if.hpp> +#include <iterator> +#include <algorithm> +#ifndef _STLP_NO_IOSTREAMS +# ifndef BOOST_OLD_IOSTREAMS +# include <ostream> +# else +# include <ostream.h> +# endif +#endif // _STLP_NO_IOSTREAMS +#include <cstddef> + +/*! \file + Defines the \c iterator_class and related functions. + \c iterator_range is a simple wrapper of iterator pair idiom. It provides + a rich subset of Container interface. +*/ + + +namespace boost +{ + namespace iterator_range_detail + { + // + // The functions adl_begin and adl_end are implemented in a separate + // class for gcc-2.9x + // + template<typename IteratorT> + struct iterator_range_impl { + template< class ForwardRange > + static IteratorT adl_begin( ForwardRange& r ) + { + return IteratorT( boost::begin( r ) ); + } + + template< class ForwardRange > + static IteratorT adl_end( ForwardRange& r ) + { + return IteratorT( boost::end( r ) ); + } + }; + + template< class Left, class Right > + inline bool equal( const Left& l, const Right& r ) + { + typedef BOOST_DEDUCED_TYPENAME boost::range_difference<Left>::type sz_type; + + sz_type l_size = boost::distance( l ), + r_size = boost::distance( r ); + + if( l_size != r_size ) + return false; + + return std::equal( boost::begin(l), boost::end(l), + boost::begin(r) ); + } + + template< class Left, class Right > + inline bool less_than( const Left& l, const Right& r ) + { + return std::lexicographical_compare( boost::begin(l), + boost::end(l), + boost::begin(r), + boost::end(r) ); + } + + struct range_tag { }; + struct const_range_tag { }; + + } + +// iterator range template class -----------------------------------------// + + //! iterator_range class + /*! + An \c iterator_range delimits a range in a sequence by beginning and ending iterators. + An iterator_range can be passed to an algorithm which requires a sequence as an input. + For example, the \c toupper() function may be used most frequently on strings, + but can also be used on iterator_ranges: + + \code + boost::tolower( find( s, "UPPERCASE STRING" ) ); + \endcode + + Many algorithms working with sequences take a pair of iterators, + delimiting a working range, as an arguments. The \c iterator_range class is an + encapsulation of a range identified by a pair of iterators. + It provides a collection interface, + so it is possible to pass an instance to an algorithm requiring a collection as an input. + */ + template<typename IteratorT> + class iterator_range + { + protected: // Used by sub_range + //! implementation class + typedef iterator_range_detail::iterator_range_impl<IteratorT> impl; + public: + + //! this type + typedef iterator_range<IteratorT> type; + //BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type); + + //! Encapsulated value type + typedef BOOST_DEDUCED_TYPENAME + iterator_value<IteratorT>::type value_type; + + //! Difference type + typedef BOOST_DEDUCED_TYPENAME + iterator_difference<IteratorT>::type difference_type; + + //! Size type + typedef std::size_t size_type; // note: must be unsigned + + //! This type + typedef iterator_range<IteratorT> this_type; + + //! Refence type + // + // Needed because value-type is the same for + // const and non-const iterators + // + typedef BOOST_DEDUCED_TYPENAME + iterator_reference<IteratorT>::type reference; + + //! const_iterator type + /*! + There is no distinction between const_iterator and iterator. + These typedefs are provides to fulfill container interface + */ + typedef IteratorT const_iterator; + //! iterator type + typedef IteratorT iterator; + + private: // for return value of operator()() + typedef BOOST_DEDUCED_TYPENAME + boost::mpl::if_< boost::is_abstract<value_type>, + reference, value_type >::type abstract_value_type; + + public: + iterator_range() : m_Begin( iterator() ), m_End( iterator() ) + #ifndef NDEBUG + , singular( true ) + #endif + { } + + //! Constructor from a pair of iterators + template< class Iterator > + iterator_range( Iterator Begin, Iterator End ) : + 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 ) ) + #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 ) ) + #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 ) ) + #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 ) ) + #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(); + + #ifndef NDEBUG + singular = r.singular; + #endif + return *this; + } + #endif + + template< class Iterator > + iterator_range& operator=( const iterator_range<Iterator>& r ) + { + m_Begin = r.begin(); + m_End = r.end(); + #ifndef NDEBUG + singular = r.is_singular(); + #endif + return *this; + } + + template< class ForwardRange > + iterator_range& operator=( ForwardRange& r ) + { + m_Begin = impl::adl_begin( r ); + m_End = impl::adl_end( r ); + #ifndef NDEBUG + singular = false; + #endif + return *this; + } + + template< class ForwardRange > + iterator_range& operator=( const ForwardRange& r ) + { + 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; + } + + difference_type size() const + { + BOOST_ASSERT( !is_singular() ); + return m_End - m_Begin; + } + + bool empty() const + { + BOOST_ASSERT( !is_singular() ); + return m_Begin == m_End; + } + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + operator bool() const + { + return !empty(); + } +#else + typedef iterator (iterator_range::*unspecified_bool_type) () const; + operator unspecified_bool_type() const + { + return empty() ? 0: &iterator_range::end; + } +#endif + + bool equal( const iterator_range& r ) const + { + BOOST_ASSERT( !is_singular() ); + return m_Begin == r.m_Begin && m_End == r.m_End; + } + + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + + 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 + { + BOOST_ASSERT( !is_singular() ); + return iterator_range_detail::less_than( *this, r ); + } + +#endif + + public: // convenience + reference front() const + { + BOOST_ASSERT( !empty() ); + return *m_Begin; + } + + reference back() const + { + BOOST_ASSERT( !empty() ); + IteratorT last( m_End ); + return *--last; + } + + reference operator[]( difference_type at ) const + { + BOOST_ASSERT( at >= 0 && at < size() ); + return m_Begin[at]; + } + + // + // When storing transform iterators, operator[]() + // fails because it returns by reference. Therefore + // operator()() is provided for these cases. + // + abstract_value_type operator()( difference_type at ) const + { + BOOST_ASSERT( at >= 0 && at < size() ); + return m_Begin[at]; + } + + 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; + } + + private: + // begin and end iterators + IteratorT m_Begin; + IteratorT m_End; + + #ifndef NDEBUG + bool singular; + #endif + + public: + bool is_singular() const + { + #ifndef NDEBUG + return singular; + #else + return false; + #endif + } + + protected: + // + // Allow subclasses an easy way to access the + // base type + // + typedef iterator_range iterator_range_; + }; + +// iterator range free-standing operators ---------------------------// + +#ifndef _STLP_NO_IOSTREAMS +# ifndef BOOST_OLD_IOSTREAMS + + //! iterator_range output operator + /*! + Output the range to an ostream. Elements are outputed + in a sequence without separators. + */ + template< typename IteratorT, typename Elem, typename Traits > + inline std::basic_ostream<Elem,Traits>& operator<<( + std::basic_ostream<Elem, Traits>& Os, + const iterator_range<IteratorT>& r ) + { + std::copy( r.begin(), r.end(), + std::ostream_iterator< BOOST_DEDUCED_TYPENAME + iterator_value<IteratorT>::type, + Elem, Traits>(Os) ); + return Os; + } + +# else + + //! iterator_range output operator + /*! + Output the range to an ostream. Elements are outputed + in a sequence without separators. + */ + template< typename IteratorT > + inline std::ostream& operator<<( + std::ostream& Os, + const iterator_range<IteratorT>& r ) + { + std::copy( r.begin(), r.end(), std::ostream_iterator<char>(Os)); + return Os; + } + +# endif +#endif // _STLP_NO_IOSTREAMS + + ///////////////////////////////////////////////////////////////////// + // comparison operators + ///////////////////////////////////////////////////////////////////// + + template< class IteratorT, class ForwardRange > + inline bool operator==( const ForwardRange& l, + const iterator_range<IteratorT>& r ) + { + return iterator_range_detail::equal( l, r ); + } + + template< class IteratorT, class ForwardRange > + inline bool operator!=( const ForwardRange& l, + const iterator_range<IteratorT>& r ) + { + return !iterator_range_detail::equal( l, r ); + } + + template< class IteratorT, class ForwardRange > + inline bool operator<( const ForwardRange& l, + const iterator_range<IteratorT>& r ) + { + return iterator_range_detail::less_than( l, r ); + } + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING +#else + template< class Iterator1T, class Iterator2T > + inline bool operator==( const iterator_range<Iterator1T>& l, + const iterator_range<Iterator2T>& r ) + { + return iterator_range_detail::equal( l, r ); + } + + template< class IteratorT, class ForwardRange > + inline bool operator==( const iterator_range<IteratorT>& l, + const ForwardRange& r ) + { + return iterator_range_detail::equal( l, r ); + } + + + template< class Iterator1T, class Iterator2T > + inline bool operator!=( const iterator_range<Iterator1T>& l, + const iterator_range<Iterator2T>& r ) + { + return !iterator_range_detail::equal( l, r ); + } + + template< class IteratorT, class ForwardRange > + inline bool operator!=( const iterator_range<IteratorT>& l, + const ForwardRange& r ) + { + return !iterator_range_detail::equal( l, r ); + } + + + template< class Iterator1T, class Iterator2T > + inline bool operator<( const iterator_range<Iterator1T>& l, + const iterator_range<Iterator2T>& r ) + { + return iterator_range_detail::less_than( l, r ); + } + + template< class IteratorT, class ForwardRange > + inline bool operator<( const iterator_range<IteratorT>& l, + const ForwardRange& r ) + { + return iterator_range_detail::less_than( l, r ); + } + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +// iterator range utilities -----------------------------------------// + + //! iterator_range construct helper + /*! + Construct an \c iterator_range from a pair of iterators + + \param Begin A begin iterator + \param End An end iterator + \return iterator_range object + */ + template< typename IteratorT > + inline iterator_range< IteratorT > + make_iterator_range( IteratorT Begin, IteratorT End ) + { + return iterator_range<IteratorT>( Begin, End ); + } + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + + template< typename Range > + inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type > + make_iterator_range( Range& r ) + { + return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type > + ( boost::begin( r ), boost::end( r ) ); + } + +#else + //! iterator_range construct helper + /*! + Construct an \c iterator_range from a \c Range containing the begin + and end iterators. + */ + template< class ForwardRange > + inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type > + make_iterator_range( ForwardRange& r ) + { + return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type > + ( r, iterator_range_detail::range_tag() ); + } + + template< class ForwardRange > + inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type > + make_iterator_range( const ForwardRange& r ) + { + return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type > + ( r, iterator_range_detail::const_range_tag() ); + } + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + + namespace iterator_range_detail + { + template< class Range > + 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 ) + { + // + // Not worth the effort + // + //if( advance_begin == 0 && advance_end == 0 ) + // return make_iterator_range( r ); + // + + BOOST_DEDUCED_TYPENAME range_iterator<Range>::type + new_begin = boost::begin( r ), + new_end = boost::end( r ); + std::advance( new_begin, advance_begin ); + std::advance( new_end, advance_end ); + return make_iterator_range( new_begin, new_end ); + } + } + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + + template< class Range > + 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 ) + { + //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" ); + return iterator_range_detail::make_range_impl( r, advance_begin, advance_end ); + } + +#else + + template< class Range > + 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 ) + { + //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" ); + return iterator_range_detail::make_range_impl( r, advance_begin, advance_end ); + } + + template< class Range > + 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 ) + { + //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" ); + return iterator_range_detail::make_range_impl( r, advance_begin, advance_end ); + } + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + + //! copy a range into a sequence + /*! + Construct a new sequence of the specified type from the elements + in the given range + + \param Range An input range + \return New sequence + */ + template< typename SeqT, typename Range > + inline SeqT copy_range( const Range& r ) + { + return SeqT( boost::begin( r ), boost::end( r ) ); + } + +} // namespace 'boost' + +#undef BOOST_OLD_IOSTREAMS + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) + #pragma warning( pop ) +#endif + +#endif + diff --git a/3rdParty/Boost/src/boost/range/mutable_iterator.hpp b/3rdParty/Boost/src/boost/range/mutable_iterator.hpp new file mode 100644 index 0000000..2f45c16 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/mutable_iterator.hpp @@ -0,0 +1,64 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP +#define BOOST_RANGE_MUTABLE_ITERATOR_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# 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> + +namespace boost +{ + ////////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////////// + + template< typename C > + struct range_mutable_iterator + { + typedef BOOST_DEDUCED_TYPENAME C::iterator type; + }; + + ////////////////////////////////////////////////////////////////////////// + // pair + ////////////////////////////////////////////////////////////////////////// + + template< typename Iterator > + struct range_mutable_iterator< std::pair<Iterator,Iterator> > + { + typedef Iterator type; + }; + + ////////////////////////////////////////////////////////////////////////// + // array + ////////////////////////////////////////////////////////////////////////// + + template< typename T, std::size_t sz > + struct range_mutable_iterator< T[sz] > + { + typedef T* type; + }; + +} // namespace boost + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif diff --git a/3rdParty/Boost/src/boost/range/rbegin.hpp b/3rdParty/Boost/src/boost/range/rbegin.hpp new file mode 100644 index 0000000..78e5f61 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/rbegin.hpp @@ -0,0 +1,65 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_RBEGIN_HPP +#define BOOST_RANGE_RBEGIN_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/end.hpp> +#include <boost/range/reverse_iterator.hpp> + +namespace boost +{ + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type +rbegin( C& c ) +{ + return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::end( c ) ); +} + +#else + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type +rbegin( C& c ) +{ + 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_reverse_iterator<const C>::type +rbegin( const C& c ) +{ + typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type + iter_type; + return iter_type( boost::end( c ) ); +} + +#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +template< class T > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type +const_rbegin( const T& r ) +{ + return boost::rbegin( r ); +} + +} // namespace 'boost' + +#endif + diff --git a/3rdParty/Boost/src/boost/range/rend.hpp b/3rdParty/Boost/src/boost/range/rend.hpp new file mode 100644 index 0000000..fd79aa2 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/rend.hpp @@ -0,0 +1,65 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_REND_HPP +#define BOOST_RANGE_REND_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/begin.hpp> +#include <boost/range/reverse_iterator.hpp> + +namespace boost +{ + +#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type +rend( C& c ) +{ + return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::begin( c ) ); +} + +#else + +template< class C > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type +rend( C& c ) +{ + 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_reverse_iterator<const C>::type +rend( const C& c ) +{ + typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type + iter_type; + return iter_type( boost::begin( c ) ); +} + +#endif + +template< class T > +inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type +const_rend( const T& r ) +{ + return boost::rend( r ); +} + +} // namespace 'boost' + +#endif + diff --git a/3rdParty/Boost/src/boost/range/result_iterator.hpp b/3rdParty/Boost/src/boost/range/result_iterator.hpp new file mode 100644 index 0000000..ba09c5f --- /dev/null +++ b/3rdParty/Boost/src/boost/range/result_iterator.hpp @@ -0,0 +1,33 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_RESULT_ITERATOR_HPP +#define BOOST_RANGE_RESULT_ITERATOR_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include <boost/range/iterator.hpp> + +namespace boost +{ + // + // This interface is deprecated, use range_iterator<T> + // + + template< typename C > + struct range_result_iterator : range_iterator<C> + { }; + +} // namespace boost + + +#endif diff --git a/3rdParty/Boost/src/boost/range/reverse_iterator.hpp b/3rdParty/Boost/src/boost/range/reverse_iterator.hpp new file mode 100644 index 0000000..f8e9221 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/reverse_iterator.hpp @@ -0,0 +1,40 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_REVERSE_ITERATOR_HPP +#define BOOST_RANGE_REVERSE_ITERATOR_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/config.hpp> +#include <boost/range/iterator.hpp> +#include <boost/iterator/reverse_iterator.hpp> + + +namespace boost +{ + ////////////////////////////////////////////////////////////////////////// + // default + ////////////////////////////////////////////////////////////////////////// + + template< typename C > + struct range_reverse_iterator + { + typedef reverse_iterator< + BOOST_DEDUCED_TYPENAME range_iterator<C>::type > type; + }; + + +} // namespace boost + + +#endif diff --git a/3rdParty/Boost/src/boost/range/size.hpp b/3rdParty/Boost/src/boost/range/size.hpp new file mode 100644 index 0000000..311a692 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/size.hpp @@ -0,0 +1,36 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_SIZE_HPP +#define BOOST_RANGE_SIZE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/difference_type.hpp> +#include <boost/assert.hpp> + +namespace boost +{ + + template< class T > + inline BOOST_DEDUCED_TYPENAME range_difference<T>::type size( const T& r ) + { + BOOST_ASSERT( (boost::end( r ) - boost::begin( r )) >= 0 && + "reachability invariant broken!" ); + return boost::end( r ) - boost::begin( r ); + } + +} // namespace 'boost' + +#endif diff --git a/3rdParty/Boost/src/boost/range/size_type.hpp b/3rdParty/Boost/src/boost/range/size_type.hpp new file mode 100644 index 0000000..7ed8dfa --- /dev/null +++ b/3rdParty/Boost/src/boost/range/size_type.hpp @@ -0,0 +1,78 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_SIZE_TYPE_HPP +#define BOOST_RANGE_SIZE_TYPE_HPP + +#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/size_type.hpp> +#else + +#include <boost/type_traits/remove_const.hpp> +#include <cstddef> +#include <utility> + +namespace boost +{ + namespace detail + { + + ////////////////////////////////////////////////////////////////////////// + // 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< 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 + + +#endif diff --git a/3rdParty/Boost/src/boost/range/value_type.hpp b/3rdParty/Boost/src/boost/range/value_type.hpp new file mode 100644 index 0000000..95c7580 --- /dev/null +++ b/3rdParty/Boost/src/boost/range/value_type.hpp @@ -0,0 +1,34 @@ +// Boost.Range library +// +// Copyright Thorsten Ottosen 2003-2004. 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) +// +// For more information, see http://www.boost.org/libs/range/ +// + +#ifndef BOOST_RANGE_VALUE_TYPE_HPP +#define BOOST_RANGE_VALUE_TYPE_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma once +#endif + +#include <boost/range/config.hpp> +#include <boost/range/iterator.hpp> + +//#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 : iterator_value< typename range_iterator<T>::type > + { }; +} + +#endif |