diff options
Diffstat (limited to 'contrib/src/boost/range/detail')
| -rw-r--r-- | contrib/src/boost/range/detail/as_literal.hpp | 33 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/begin.hpp | 83 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/common.hpp | 118 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/detail_str.hpp | 376 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/end.hpp | 86 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/extract_optional_type.hpp | 48 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/has_member_size.hpp | 66 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/implementation_help.hpp | 114 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/misc_concept.hpp | 33 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/msvc_has_iterator_workaround.hpp | 132 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/remove_extent.hpp | 157 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/safe_bool.hpp | 72 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/sfinae.hpp | 77 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/size_type.hpp | 55 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/str_types.hpp | 38 | ||||
| -rw-r--r-- | contrib/src/boost/range/detail/value_type.hpp | 72 |
16 files changed, 1560 insertions, 0 deletions
diff --git a/contrib/src/boost/range/detail/as_literal.hpp b/contrib/src/boost/range/detail/as_literal.hpp new file mode 100644 index 0000000..8b219ea --- /dev/null +++ b/contrib/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) +# 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/contrib/src/boost/range/detail/begin.hpp b/contrib/src/boost/range/detail/begin.hpp new file mode 100644 index 0000000..1d9390f --- /dev/null +++ b/contrib/src/boost/range/detail/begin.hpp @@ -0,0 +1,83 @@ +// 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> + +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_> + { + template<typename T> + static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t) + { + return t; + } + }; + + } // namespace 'range_detail' + + namespace range_adl_barrier + { + 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/contrib/src/boost/range/detail/common.hpp b/contrib/src/boost/range/detail/common.hpp new file mode 100644 index 0000000..00b665b --- /dev/null +++ b/contrib/src/boost/range/detail/common.hpp @@ -0,0 +1,118 @@ +// 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) +# pragma once +#endif + +#include <boost/range/config.hpp> +#include <boost/range/detail/sfinae.hpp> +#include <boost/type_traits/is_void.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/int.hpp> +#include <boost/mpl/or.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::mpl::or_<boost::mpl::bool_<is_const_char_ptr_>, boost::mpl::bool_<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/contrib/src/boost/range/detail/detail_str.hpp b/contrib/src/boost/range/detail/detail_str.hpp new file mode 100644 index 0000000..5ef7a34 --- /dev/null +++ b/contrib/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.hpp> +#include <boost/range/detail/value_type.hpp> +#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/contrib/src/boost/range/detail/end.hpp b/contrib/src/boost/range/detail/end.hpp new file mode 100644 index 0000000..f2f7178 --- /dev/null +++ b/contrib/src/boost/range/detail/end.hpp @@ -0,0 +1,86 @@ +// 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> + +#include <boost/range/detail/implementation_help.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/detail/common.hpp> + +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_> + { + template<typename T> + static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t) + { + return t + remove_extent<T>::size; + } + }; + + } // namespace 'range_detail' + + namespace range_adl_barrier + { + 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 range_adl_barrier + +} // namespace 'boost' + +#endif diff --git a/contrib/src/boost/range/detail/extract_optional_type.hpp b/contrib/src/boost/range/detail/extract_optional_type.hpp new file mode 100644 index 0000000..0381434 --- /dev/null +++ b/contrib/src/boost/range/detail/extract_optional_type.hpp @@ -0,0 +1,48 @@ +// Boost.Range library +// +// Copyright Arno Schoedl & Neil Groves 2009. +// 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_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED +#define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED + +#if defined(_MSC_VER) +# pragma once +#endif + +#include <boost/config.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/mpl/has_xxx.hpp> + +#if !defined(BOOST_MPL_CFG_NO_HAS_XXX) + +// Defines extract_some_typedef<T> which exposes T::some_typedef as +// extract_some_typedef<T>::type if T::some_typedef exists. Otherwise +// extract_some_typedef<T> is empty. +#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \ + BOOST_MPL_HAS_XXX_TRAIT_DEF(a_typedef) \ + template< typename C, bool B = BOOST_PP_CAT(has_, a_typedef)<C>::value > \ + struct BOOST_PP_CAT(extract_, a_typedef) \ + {}; \ + template< typename C > \ + struct BOOST_PP_CAT(extract_, a_typedef)< C, true > \ + { \ + typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \ + }; + +#else + +#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \ + template< typename C > \ + struct BOOST_PP_CAT(extract_, a_typedef) \ + { \ + typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \ + }; + +#endif + +#endif // include guard diff --git a/contrib/src/boost/range/detail/has_member_size.hpp b/contrib/src/boost/range/detail/has_member_size.hpp new file mode 100644 index 0000000..0c639aa --- /dev/null +++ b/contrib/src/boost/range/detail/has_member_size.hpp @@ -0,0 +1,66 @@ +// Boost.Range library +// +// Copyright Neil Groves 2014. +// +// Use, modification and distribution are 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_HAS_MEMBER_SIZE_HPP +#define BOOST_RANGE_DETAIL_HAS_MEMBER_SIZE_HPP + +#include <boost/type_traits/is_class.hpp> +#include <boost/type_traits/is_member_function_pointer.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/cstdint.hpp> + +namespace boost +{ + namespace range_detail + { + +template<class T> +class has_member_size_impl +{ +private: + template<class U, U> + class check + { + }; + + template<class C> + static boost::uint8_t f(check<std::size_t(C::*)(void) const, &C::size>*); + + template<class C> + static boost::uint16_t f(...); + +public: + static const bool value = + (sizeof(f<T>(0)) == sizeof(boost::uint8_t)); + + typedef typename mpl::if_c< + (sizeof(f<T>(0)) == sizeof(boost::uint8_t)), + mpl::true_, + mpl::false_ + >::type type; +}; + +template<class T> +struct has_member_size +{ + typedef typename mpl::and_< + typename is_class<T>::type, + typename has_member_size_impl<const T>::type + >::type type; + + static const bool value = + is_class<T>::value && has_member_size_impl<const T>::value; +}; + + } // namespace range_detail +}// namespace boost + +#endif // include guard diff --git a/contrib/src/boost/range/detail/implementation_help.hpp b/contrib/src/boost/range/detail/implementation_help.hpp new file mode 100644 index 0000000..f35953f --- /dev/null +++ b/contrib/src/boost/range/detail/implementation_help.hpp @@ -0,0 +1,114 @@ +// 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; + } + + inline bool is_same_address(const void* l, const void* r) + { + return l == r; + } + + template<class T1, class T2> + inline bool is_same_object(const T1& l, const T2& r) + { + return range_detail::is_same_address(&l, &r); + } + + } // namespace 'range_detail' + +} // namespace 'boost' + + +#endif diff --git a/contrib/src/boost/range/detail/misc_concept.hpp b/contrib/src/boost/range/detail/misc_concept.hpp new file mode 100644 index 0000000..74cb919 --- /dev/null +++ b/contrib/src/boost/range/detail/misc_concept.hpp @@ -0,0 +1,33 @@ +// Boost.Range library concept checks +// +// Copyright Neil Groves 2009. Use, modification and distribution +// are 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) +// +#ifndef BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED +#define BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED + +#include <boost/concept_check.hpp> + +namespace boost +{ + namespace range_detail + { + template<typename T1, typename T2> + class SameTypeConcept + { + public: + BOOST_CONCEPT_USAGE(SameTypeConcept) + { + same_type(a,b); + } + private: + template<typename T> void same_type(T,T) {} + T1 a; + T2 b; + }; + } +} + +#endif // include guard diff --git a/contrib/src/boost/range/detail/msvc_has_iterator_workaround.hpp b/contrib/src/boost/range/detail/msvc_has_iterator_workaround.hpp new file mode 100644 index 0000000..62b67fd --- /dev/null +++ b/contrib/src/boost/range/detail/msvc_has_iterator_workaround.hpp @@ -0,0 +1,132 @@ +// Boost.Range library +// +// Copyright Eric Niebler 2014. 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_MSVC_HAS_ITERATOR_WORKAROUND_HPP +#define BOOST_RANGE_DETAIL_MSVC_HAS_ITERATOR_WORKAROUND_HPP + +#if defined(_MSC_VER) +# pragma once +#endif + +#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP +# error This file should only be included from <boost/range/mutable_iterator.hpp> +#endif + +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600) +namespace boost +{ +namespace cb_details +{ + template <class Buff, class Traits> + struct iterator; +} + +namespace python +{ + template <class Container + , class NextPolicies /*= objects::default_iterator_call_policies*/> + struct iterator; +} + +namespace type_erasure +{ + template< + class Traversal, + class T /*= _self*/, + class Reference /*= ::boost::use_default*/, + class DifferenceType /*= ::std::ptrdiff_t*/, + class ValueType /*= typename deduced<iterator_value_type<T> >::type*/ + > + struct iterator; +} + +namespace unordered { namespace iterator_detail +{ + template <typename Node> + struct iterator; +}} + +namespace container { namespace container_detail +{ + template<class IIterator, bool IsConst> + class iterator; +}} + +namespace spirit { namespace lex { namespace lexertl +{ + template <typename Functor> + class iterator; +}}} + +namespace range_detail +{ + template <class Buff, class Traits> + struct has_iterator< ::boost::cb_details::iterator<Buff, Traits> > + : mpl::false_ + {}; + + template <class Buff, class Traits> + struct has_iterator< ::boost::cb_details::iterator<Buff, Traits> const> + : mpl::false_ + {}; + + template <class Container, class NextPolicies> + struct has_iterator< ::boost::python::iterator<Container, NextPolicies> > + : mpl::false_ + {}; + + template <class Container, class NextPolicies> + struct has_iterator< ::boost::python::iterator<Container, NextPolicies> const> + : mpl::false_ + {}; + + template<class Traversal, class T, class Reference, class DifferenceType, class ValueType> + struct has_iterator< ::boost::type_erasure::iterator<Traversal, T, Reference, DifferenceType, ValueType> > + : mpl::false_ + {}; + + template<class Traversal, class T, class Reference, class DifferenceType, class ValueType> + struct has_iterator< ::boost::type_erasure::iterator<Traversal, T, Reference, DifferenceType, ValueType> const> + : mpl::false_ + {}; + + template <typename Node> + struct has_iterator< ::boost::unordered::iterator_detail::iterator<Node> > + : mpl::false_ + {}; + + template <typename Node> + struct has_iterator< ::boost::unordered::iterator_detail::iterator<Node> const> + : mpl::false_ + {}; + + template<class IIterator, bool IsConst> + struct has_iterator< ::boost::container::container_detail::iterator<IIterator, IsConst> > + : mpl::false_ + {}; + + template<class IIterator, bool IsConst> + struct has_iterator< ::boost::container::container_detail::iterator<IIterator, IsConst> const> + : mpl::false_ + {}; + + template <typename Functor> + struct has_iterator< ::boost::spirit::lex::lexertl::iterator<Functor> > + : mpl::false_ + {}; + + template <typename Functor> + struct has_iterator< ::boost::spirit::lex::lexertl::iterator<Functor> const> + : mpl::false_ + {}; +} +} +#endif +#endif diff --git a/contrib/src/boost/range/detail/remove_extent.hpp b/contrib/src/boost/range/detail/remove_extent.hpp new file mode 100644 index 0000000..68e4597 --- /dev/null +++ b/contrib/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/contrib/src/boost/range/detail/safe_bool.hpp b/contrib/src/boost/range/detail/safe_bool.hpp new file mode 100644 index 0000000..182e510 --- /dev/null +++ b/contrib/src/boost/range/detail/safe_bool.hpp @@ -0,0 +1,72 @@ +// This header intentionally has no include guards. +// +// Copyright (c) 2010 Neil Groves +// Distributed under 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 +// +// This code utilises the experience gained during the evolution of +// <boost/smart_ptr/operator_bool.hpp> +#ifndef BOOST_RANGE_SAFE_BOOL_INCLUDED_HPP +#define BOOST_RANGE_SAFE_BOOL_INCLUDED_HPP + +#include <boost/config.hpp> +#include <boost/range/config.hpp> + +namespace boost +{ + namespace range_detail + { + +template<class DataMemberPtr> +class safe_bool +{ +public: + typedef safe_bool this_type; + +#if (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570)) || defined(__CINT_) + typedef bool unspecified_bool_type; + static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr) + { + return x; + } +#elif defined(_MANAGED) + static void unspecified_bool(this_type***) + { + } + typedef void(*unspecified_bool_type)(this_type***); + static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr) + { + return x ? unspecified_bool : 0; + } +#elif \ + ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \ + ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \ + ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) ) + + typedef bool (this_type::*unspecified_bool_type)() const; + + static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr) + { + return x ? &this_type::detail_safe_bool_member_fn : 0; + } +private: + bool detail_safe_bool_member_fn() const { return false; } +#else + typedef DataMemberPtr unspecified_bool_type; + static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr p) + { + return x ? p : 0; + } +#endif +private: + safe_bool(); + safe_bool(const safe_bool&); + void operator=(const safe_bool&); + ~safe_bool(); +}; + + } // namespace range_detail +} // namespace boost + +#endif // include guard diff --git a/contrib/src/boost/range/detail/sfinae.hpp b/contrib/src/boost/range/detail/sfinae.hpp new file mode 100644 index 0000000..5b2c61e --- /dev/null +++ b/contrib/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/contrib/src/boost/range/detail/size_type.hpp b/contrib/src/boost/range/detail/size_type.hpp new file mode 100644 index 0000000..78a60a4 --- /dev/null +++ b/contrib/src/boost/range/detail/size_type.hpp @@ -0,0 +1,55 @@ +// 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< typename C > + struct pts + { + typedef std::size_t type; + }; + }; + + template<> + struct range_size_type_<std_container_> + { + template< typename C > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME C::size_type 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/contrib/src/boost/range/detail/str_types.hpp b/contrib/src/boost/range/detail/str_types.hpp new file mode 100644 index 0000000..f8cab19 --- /dev/null +++ b/contrib/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/contrib/src/boost/range/detail/value_type.hpp b/contrib/src/boost/range/detail/value_type.hpp new file mode 100644 index 0000000..2784514 --- /dev/null +++ b/contrib/src/boost/range/detail/value_type.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_DETAIL_VALUE_TYPE_HPP +#define BOOST_RANGE_DETAIL_VALUE_TYPE_HPP + +#include <boost/range/detail/common.hpp> +#include <boost/range/detail/remove_extent.hpp> +#include <boost/iterator/iterator_traits.hpp> + +////////////////////////////////////////////////////////////////////////////// +// missing partial specialization workaround. +////////////////////////////////////////////////////////////////////////////// + +namespace boost +{ + namespace range_detail + { + template< typename T > + struct range_value_type_; + + template<> + struct range_value_type_<std_container_> + { + template< typename C > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME C::value_type type; + }; + }; + + template<> + struct range_value_type_<std_pair_> + { + template< typename P > + struct pts + { + typedef BOOST_RANGE_DEDUCED_TYPENAME boost::iterator_value< BOOST_RANGE_DEDUCED_TYPENAME P::first_type >::type type; + }; + }; + + template<> + struct range_value_type_<array_> + { + template< typename T > + struct pts + { + typedef BOOST_DEDUCED_TYPENAME remove_extent<T>::type type; + }; + }; + + } + + template< typename C > + class range_value + { + typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type; + public: + typedef BOOST_DEDUCED_TYPENAME range_detail::range_value_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type; + }; + +} + +#endif + |