boostorg/core
1
0
Fork 1
mirror of https://github.com/boostorg/core.git synced 2025-07-31 05:17:22 +02:00
Code Issues Packages Projects Releases Wiki Activity

Deprecated boost::core::is_same and the associated header.

Browse Source 
Moved is_same implementation to detail (both directory and namespace)
to use in the public headers and avoid introducing new dependencies.
The documentation now recommends users to use Boost.TypeTraits or
C++ standard library instead.

Also, removed unnecessary includes and added missing ones in a few
places.
This commit is contained in:
Andrey Semashev
2022-12-22 15:46:55 +03:00
parent 75c765cc13
commit 86bf1d4aec
34 changed files with 206 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
doc/changes.qbk
View File

@ -11,6 +11,9 @@
* Added [link core.snprintf `boost/core/snprintf.hpp`] header with portable definitions of `snprintf`, `vsnprintf` and * Added [link core.snprintf `boost/core/snprintf.hpp`] header with portable definitions of `snprintf`, `vsnprintf` and
their `wchar_t` counterparts. their `wchar_t` counterparts.
* Deprecated `boost/core/is_same.hpp` and `boost::core::is_same`. The header will be removed in a future release.
Users are advised to use [@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/index.html Boost.TypeTraits]
or C++ standard library type traits instead.
[endsect] [endsect]

5
doc/is_same.qbk
View File

@ -17,6 +17,11 @@
[section Header <boost/core/is_same.hpp>] [section Header <boost/core/is_same.hpp>]
[warning This component is deprecated and will be removed in a future release.
Users are recommended to use `boost::is_same` from
[@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/index.html Boost.TypeTraits]
or `std::is_same` from C++ standard library `<type_traits>` instead.]
The header `<boost/core/is_same.hpp>` defines the class template The header `<boost/core/is_same.hpp>` defines the class template
`boost::core::is_same<T1,T2>`. It defines a nested integral constant `boost::core::is_same<T1,T2>`. It defines a nested integral constant
`value` which is `true` when `T1` and `T2` are the same type, and `value` which is `true` when `T1` and `T2` are the same type, and

4
doc/lightweight_test.qbk
View File

@ -326,14 +326,14 @@ parentheses.)
`` ``
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/is_same.hpp> #include <boost/type_traits/is_same.hpp>
template<class T, class U> struct X template<class T, class U> struct X
{ {
typedef T type; typedef T type;
}; };
using boost::core::is_same; using boost::is_same;
int main() int main()
{ {

39
include/boost/core/detail/is_same.hpp Normal file
View File

@ -0,0 +1,39 @@
#ifndef BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED
#define BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED
// is_same<T1,T2>::value is true when T1 == T2
//
// Copyright 2014 Peter Dimov
//
// 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
#include <boost/config.hpp>
#if defined(BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
namespace boost
{
namespace core
{
namespace detail
{
template< class T1, class T2 > struct is_same
{
BOOST_STATIC_CONSTANT( bool, value = false );
};
template< class T > struct is_same< T, T >
{
BOOST_STATIC_CONSTANT( bool, value = true );
};
} // namespace detail
} // namespace core
} // namespace boost
#endif // #ifndef BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED

10
include/boost/core/detail/string_view.hpp
View File

@ -14,7 +14,7 @@
// https://www.boost.org/LICENSE_1_0.txt // https://www.boost.org/LICENSE_1_0.txt
#include <boost/core/enable_if.hpp> #include <boost/core/enable_if.hpp>
#include <boost/core/is_same.hpp> #include <boost/core/detail/is_same.hpp>
#include <boost/assert.hpp> #include <boost/assert.hpp>
#include <boost/assert/source_location.hpp> #include <boost/assert/source_location.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
@ -381,7 +381,7 @@ public:
} }
template<class End> BOOST_CXX14_CONSTEXPR basic_string_view( Ch const* first, End last, template<class End> BOOST_CXX14_CONSTEXPR basic_string_view( Ch const* first, End last,
typename boost::enable_if<is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( last - first ) typename boost::enable_if<boost::core::detail::is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( last - first )
{ {
BOOST_ASSERT( last - first >= 0 ); BOOST_ASSERT( last - first >= 0 );
} }
@ -399,7 +399,7 @@ public:
#endif #endif
template<class Ch2> basic_string_view( boost::basic_string_view<Ch2, std::char_traits<Ch2> > const& str, template<class Ch2> basic_string_view( boost::basic_string_view<Ch2, std::char_traits<Ch2> > const& str,
typename boost::enable_if<is_same<Ch, Ch2> >::type* = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() ) typename boost::enable_if<boost::core::detail::is_same<Ch, Ch2> >::type* = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
{ {
} }
@ -430,7 +430,7 @@ public:
#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW) #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
template<class Ch2, class En = typename boost::enable_if<is_same<Ch2, Ch> >::type> template<class Ch2, class En = typename boost::enable_if<boost::core::detail::is_same<Ch2, Ch> >::type>
operator std::basic_string_view<Ch2>() const BOOST_NOEXCEPT operator std::basic_string_view<Ch2>() const BOOST_NOEXCEPT
{ {
return std::basic_string_view<Ch>( data(), size() ); return std::basic_string_view<Ch>( data(), size() );
@ -439,7 +439,7 @@ public:
#endif #endif
template<class Ch2> operator boost::basic_string_view<Ch2, template<class Ch2> operator boost::basic_string_view<Ch2,
typename boost::enable_if<boost::core::is_same<Ch2, Ch>, std::char_traits<Ch> >::type> () const BOOST_NOEXCEPT typename boost::enable_if<boost::core::detail::is_same<Ch2, Ch>, std::char_traits<Ch> >::type> () const BOOST_NOEXCEPT
{ {
return boost::basic_string_view< Ch, std::char_traits<Ch> >( data(), size() ); return boost::basic_string_view< Ch, std::char_traits<Ch> >( data(), size() );
} }

25
include/boost/core/is_same.hpp
View File

@ -1,12 +1,6 @@
#ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED #ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED
#define BOOST_CORE_IS_SAME_HPP_INCLUDED #define BOOST_CORE_IS_SAME_HPP_INCLUDED
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
// is_same<T1,T2>::value is true when T1 == T2 // is_same<T1,T2>::value is true when T1 == T2
// //
// Copyright 2014 Peter Dimov // Copyright 2014 Peter Dimov
@ -16,6 +10,15 @@
// http://www.boost.org/LICENSE_1_0.txt // http://www.boost.org/LICENSE_1_0.txt
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/core/detail/is_same.hpp>
#if defined(BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
#include <boost/config/header_deprecated.hpp>
BOOST_HEADER_DEPRECATED("<boost/type_traits/is_same.hpp>")
namespace boost namespace boost
{ {
@ -23,15 +26,7 @@ namespace boost
namespace core namespace core
{ {
template< class T1, class T2 > struct is_same using boost::core::detail::is_same;
{
BOOST_STATIC_CONSTANT( bool, value = false );
};
template< class T > struct is_same< T, T >
{
BOOST_STATIC_CONSTANT( bool, value = true );
};
} // namespace core } // namespace core

6
include/boost/core/lightweight_test_trait.hpp
View File

@ -22,7 +22,7 @@
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/core/type_name.hpp> #include <boost/core/type_name.hpp>
#include <boost/core/is_same.hpp> #include <boost/core/detail/is_same.hpp>
#include <boost/config.hpp> #include <boost/config.hpp>
namespace boost namespace boost
@ -56,7 +56,7 @@ template<class T> inline bool test_trait_same_impl_( T )
} }
template<class T1, class T2> inline void test_trait_same_impl( char const * types, template<class T1, class T2> inline void test_trait_same_impl( char const * types,
boost::core::is_same<T1, T2> same, char const * file, int line, char const * function ) boost::core::detail::is_same<T1, T2> same, char const * file, int line, char const * function )
{ {
if( test_trait_same_impl_( same ) ) if( test_trait_same_impl_( same ) )
{ {
@ -86,6 +86,6 @@ template<class T1, class T2> inline void test_trait_same_impl( char const * type
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#define BOOST_TEST_TRAIT_SAME(...) ( ::boost::detail::test_trait_same_impl(#__VA_ARGS__, ::boost::core::is_same<__VA_ARGS__>(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) ) #define BOOST_TEST_TRAIT_SAME(...) ( ::boost::detail::test_trait_same_impl(#__VA_ARGS__, ::boost::core::detail::is_same< __VA_ARGS__ >(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
#endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP #endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP

1
include/boost/core/type_name.hpp
View File

@ -14,7 +14,6 @@
// https://www.boost.org/LICENSE_1_0.txt // https://www.boost.org/LICENSE_1_0.txt
#include <boost/core/demangle.hpp> #include <boost/core/demangle.hpp>
#include <boost/core/is_same.hpp>
#include <boost/config.hpp> #include <boost/config.hpp>
#include <string> #include <string>
#include <functional> #include <functional>

2
test/CMakeLists.txt
View File

@ -6,7 +6,7 @@ include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
if(HAVE_BOOST_TEST) if(HAVE_BOOST_TEST)
boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert) boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert Boost::type_traits)
set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::type_traits) set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::type_traits)

6
test/allocator_const_pointer_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct A1 { struct A1 {
@ -22,9 +22,9 @@ struct A2 {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
boost::allocator_const_pointer<A1<char> >::type>)); boost::allocator_const_pointer<A1<char> >::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
boost::allocator_const_pointer<A2<int> >::type>)); boost::allocator_const_pointer<A2<int> >::type>));
return boost::report_errors(); return boost::report_errors();
} }

6
test/allocator_const_void_pointer_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct A1 { struct A1 {
@ -27,9 +27,9 @@ struct A2 {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
boost::allocator_const_void_pointer<A1<char> >::type>)); boost::allocator_const_void_pointer<A1<char> >::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const void*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const void*,
boost::allocator_const_void_pointer<A2<int> >::type>)); boost::allocator_const_void_pointer<A2<int> >::type>));
return boost::report_errors(); return boost::report_errors();
} }

6
test/allocator_difference_type_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct A1 { struct A1 {
@ -22,9 +22,9 @@ struct A2 {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<short, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<short,
boost::allocator_difference_type<A1<char> >::type>)); boost::allocator_difference_type<A1<char> >::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
boost::allocator_difference_type<A2<int> >::type>)); boost::allocator_difference_type<A2<int> >::type>));
return boost::report_errors(); return boost::report_errors();
} }

1
test/allocator_is_always_equal_test.cpp
View File

@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
template<class T> template<class T>

1
test/allocator_pocca_test.cpp
View File

@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
template<class T> template<class T>

1
test/allocator_pocma_test.cpp
View File

@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
template<class T> template<class T>

1
test/allocator_pocs_test.cpp
View File

@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
template<class T> template<class T>

6
test/allocator_pointer_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct A1 { struct A1 {
@ -22,9 +22,9 @@ struct A2 {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
boost::allocator_pointer<A1<char> >::type>)); boost::allocator_pointer<A1<char> >::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
boost::allocator_pointer<A2<int> >::type>)); boost::allocator_pointer<A2<int> >::type>));
return boost::report_errors(); return boost::report_errors();
} }

6
test/allocator_rebind_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct A1 { struct A1 {
@ -25,9 +25,9 @@ struct A2 {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A1<int>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<A1<int>,
boost::allocator_rebind<A1<char>, bool>::type>)); boost::allocator_rebind<A1<char>, bool>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A2<int>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<A2<int>,
boost::allocator_rebind<A2<char>, int>::type>)); boost::allocator_rebind<A2<char>, int>::type>));
return boost::report_errors(); return boost::report_errors();
} }

11
test/allocator_size_type_test.cpp
View File

@ -6,8 +6,11 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/type_traits/is_same.hpp>
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
#include <boost/type_traits/make_unsigned.hpp>
#endif
template<class T> template<class T>
struct A1 { struct A1 {
@ -24,11 +27,11 @@ struct A2 {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int, BOOST_TEST_TRAIT_TRUE((boost::is_same<int,
boost::allocator_size_type<A1<char> >::type>)); boost::allocator_size_type<A1<char> >::type>));
#if !defined(BOOST_NO_CXX11_ALLOCATOR) #if !defined(BOOST_NO_CXX11_ALLOCATOR)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same< BOOST_TEST_TRAIT_TRUE((boost::is_same<
std::make_unsigned<std::ptrdiff_t>::type, boost::make_unsigned<std::ptrdiff_t>::type,
boost::allocator_size_type<A2<int> >::type>)); boost::allocator_size_type<A2<int> >::type>));
#endif #endif
return boost::report_errors(); return boost::report_errors();

4
test/allocator_value_type_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct A { struct A {
@ -16,7 +16,7 @@ struct A {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
boost::allocator_value_type<A<int> >::type>)); boost::allocator_value_type<A<int> >::type>));
return boost::report_errors(); return boost::report_errors();
} }

6
test/allocator_void_pointer_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/allocator_access.hpp> #include <boost/core/allocator_access.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct A1 { struct A1 {
@ -27,9 +27,9 @@ struct A2 {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
boost::allocator_void_pointer<A1<char> >::type>)); boost::allocator_void_pointer<A1<char> >::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
boost::allocator_void_pointer<A2<int> >::type>)); boost::allocator_void_pointer<A2<int> >::type>));
return boost::report_errors(); return boost::report_errors();
} }

4
test/detail_iterator_test.cpp
View File

@ -10,8 +10,8 @@
#define BOOST_ALLOW_DEPRECATED_HEADERS #define BOOST_ALLOW_DEPRECATED_HEADERS
#include <boost/detail/iterator.hpp> #include <boost/detail/iterator.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/type_traits/is_same.hpp>
#include <cstddef> #include <cstddef>
#include <list> #include <list>
@ -62,7 +62,7 @@ struct iterator
int main() int main()
{ {
using boost::core::is_same; using boost::is_same;
/* /*
template<class Iterator> struct iterator_traits { template<class Iterator> struct iterator_traits {

2
test/eif_lazy_test.cpp
View File

@ -12,7 +12,7 @@
// Testing all variations of lazy_enable_if. // Testing all variations of lazy_enable_if.
#include <boost/utility/enable_if.hpp> #include <boost/core/enable_if.hpp>
#include <boost/type_traits/is_same.hpp> #include <boost/type_traits/is_same.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>

26
test/is_same_test.cpp
View File

@ -1,5 +1,5 @@
// //
// Test for core::is_same<T1,T2> // Test for core::detail::is_same<T1,T2>
// //
// Copyright 2014 Peter Dimov // Copyright 2014 Peter Dimov
// //
@ -8,7 +8,7 @@
// http://www.boost.org/LICENSE_1_0.txt // http://www.boost.org/LICENSE_1_0.txt
// //
#include <boost/core/is_same.hpp> #include <boost/core/detail/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
struct X struct X
@ -21,18 +21,18 @@ struct Y
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<X, X> )); BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<X, X> ));
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<Y, Y> )); BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<Y, Y> ));
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<void, void> )); BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<void, void> ));
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<int, int> )); BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<int, int> ));
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<void const volatile, void const volatile> )); BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<void const volatile, void const volatile> ));
BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, Y> )); BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, Y> ));
BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, X const> )); BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, X const> ));
BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, void> )); BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, void> ));
BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, int> )); BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, int> ));
BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<int, void> )); BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<int, void> ));
BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<void, void const volatile> )); BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<void, void const volatile> ));
return boost::report_errors(); return boost::report_errors();
} }

4
test/iterator_test.cpp
View File

@ -18,8 +18,8 @@
#if BOOST_CXX_VERSION < 201703 #if BOOST_CXX_VERSION < 201703
#include <boost/iterator.hpp> #include <boost/iterator.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/type_traits/is_same.hpp>
/* /*
@ -60,7 +60,7 @@ struct R
int main() int main()
{ {
using boost::core::is_same; using boost::is_same;
BOOST_TEST_TRAIT_TRUE((is_same<boost::iterator<C,T,D,P,R>::iterator_category,C>)); BOOST_TEST_TRAIT_TRUE((is_same<boost::iterator<C,T,D,P,R>::iterator_category,C>));
BOOST_TEST_TRAIT_TRUE((is_same<boost::iterator<C,T,D,P,R>::value_type,T>)); BOOST_TEST_TRAIT_TRUE((is_same<boost::iterator<C,T,D,P,R>::value_type,T>));

20
test/pointer_traits_difference_type_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/pointer_traits.hpp> #include <boost/core/pointer_traits.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct P { }; struct P { };
@ -19,23 +19,23 @@ struct E {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
boost::pointer_traits<int*>::difference_type>)); boost::pointer_traits<int*>::difference_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
boost::pointer_traits<P<int> >::difference_type>)); boost::pointer_traits<P<int> >::difference_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
boost::pointer_traits<E<int> >::difference_type>)); boost::pointer_traits<E<int> >::difference_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
boost::pointer_traits<void*>::difference_type>)); boost::pointer_traits<void*>::difference_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
boost::pointer_traits<P<void> >::difference_type>)); boost::pointer_traits<P<void> >::difference_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
boost::pointer_traits<E<void> >::difference_type>)); boost::pointer_traits<E<void> >::difference_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
boost::pointer_traits<const int*>::difference_type>)); boost::pointer_traits<const int*>::difference_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
boost::pointer_traits<P<const int> >::difference_type>)); boost::pointer_traits<P<const int> >::difference_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
boost::pointer_traits<E<const int> >::difference_type>)); boost::pointer_traits<E<const int> >::difference_type>));
return boost::report_errors(); return boost::report_errors();
} }

32
test/pointer_traits_element_type_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/pointer_traits.hpp> #include <boost/core/pointer_traits.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct P1 { }; struct P1 { };
@ -45,39 +45,39 @@ struct E {
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
boost::pointer_traits<int*>::element_type>)); boost::pointer_traits<int*>::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
boost::pointer_traits<P1<int> >::element_type>)); boost::pointer_traits<P1<int> >::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
boost::pointer_traits<P2<int, char> >::element_type>)); boost::pointer_traits<P2<int, char> >::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
boost::pointer_traits<P3<int, char, char> >::element_type>)); boost::pointer_traits<P3<int, char, char> >::element_type>));
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
boost::pointer_traits<P<int, char, char, char> >::element_type>)); boost::pointer_traits<P<int, char, char, char> >::element_type>));
#endif #endif
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
boost::pointer_traits<E1<int> >::element_type>)); boost::pointer_traits<E1<int> >::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
boost::pointer_traits<E2<int, int> >::element_type>)); boost::pointer_traits<E2<int, int> >::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
boost::pointer_traits<E3<int, int, int> >::element_type>)); boost::pointer_traits<E3<int, int, int> >::element_type>));
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
boost::pointer_traits<E<int, int, int, int> >::element_type>)); boost::pointer_traits<E<int, int, int, int> >::element_type>));
#endif #endif
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void,
boost::pointer_traits<void*>::element_type>)); boost::pointer_traits<void*>::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void,
boost::pointer_traits<P1<void> >::element_type>)); boost::pointer_traits<P1<void> >::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
boost::pointer_traits<E1<void> >::element_type>)); boost::pointer_traits<E1<void> >::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int,
boost::pointer_traits<const int*>::element_type>)); boost::pointer_traits<const int*>::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int,
boost::pointer_traits<P1<const int> >::element_type>)); boost::pointer_traits<P1<const int> >::element_type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
boost::pointer_traits<E1<const int> >::element_type>)); boost::pointer_traits<E1<const int> >::element_type>));
return boost::report_errors(); return boost::report_errors();
} }

14
test/pointer_traits_pointer_test.cpp
View File

@ -6,25 +6,25 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/pointer_traits.hpp> #include <boost/core/pointer_traits.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct P { }; struct P { };
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
boost::pointer_traits<int*>::pointer>)); boost::pointer_traits<int*>::pointer>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<int>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<int>,
boost::pointer_traits<P<int> >::pointer>)); boost::pointer_traits<P<int> >::pointer>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
boost::pointer_traits<void*>::pointer>)); boost::pointer_traits<void*>::pointer>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<void>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<void>,
boost::pointer_traits<P<void> >::pointer>)); boost::pointer_traits<P<void> >::pointer>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
boost::pointer_traits<const int*>::pointer>)); boost::pointer_traits<const int*>::pointer>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<const int>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<const int>,
boost::pointer_traits<P<const int> >::pointer>)); boost::pointer_traits<P<const int> >::pointer>));
return boost::report_errors(); return boost::report_errors();
} }

86
test/pointer_traits_rebind_test.cpp
View File

@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt) (http://www.boost.org/LICENSE_1_0.txt)
*/ */
#include <boost/core/pointer_traits.hpp> #include <boost/core/pointer_traits.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/detail/is_same.hpp>
template<class T> template<class T>
struct P1 { }; struct P1 { };
@ -55,94 +55,94 @@ struct R { };
int main() int main()
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<char*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<char*,
boost::pointer_traits<R*>::rebind_to<char>::type>)); boost::pointer_traits<R*>::rebind_to<char>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<char>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<char>,
boost::pointer_traits<P1<R> >::rebind_to<char>::type>)); boost::pointer_traits<P1<R> >::rebind_to<char>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P2<char, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P2<char, R>,
boost::pointer_traits<P2<R, R> >::rebind_to<char>::type>)); boost::pointer_traits<P2<R, R> >::rebind_to<char>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P3<char, R, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P3<char, R, R>,
boost::pointer_traits<P3<R, R, R> >::rebind_to<char>::type>)); boost::pointer_traits<P3<R, R, R> >::rebind_to<char>::type>));
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<char, R, R, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<char, R, R, R>,
boost::pointer_traits<P<R, R, R, R> >::rebind_to<char>::type>)); boost::pointer_traits<P<R, R, R, R> >::rebind_to<char>::type>));
#endif #endif
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
boost::pointer_traits<R*>::rebind_to<void>::type>)); boost::pointer_traits<R*>::rebind_to<void>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<void>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<void>,
boost::pointer_traits<P1<R> >::rebind_to<void>::type>)); boost::pointer_traits<P1<R> >::rebind_to<void>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<R*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<R*,
boost::pointer_traits<void*>::rebind_to<R>::type>)); boost::pointer_traits<void*>::rebind_to<R>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<R>,
boost::pointer_traits<P1<void> >::rebind_to<R>::type>)); boost::pointer_traits<P1<void> >::rebind_to<R>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
boost::pointer_traits<R*>::rebind_to<const int>::type>)); boost::pointer_traits<R*>::rebind_to<const int>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<const int>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<const int>,
boost::pointer_traits<P1<R> >::rebind_to<const int>::type>)); boost::pointer_traits<P1<R> >::rebind_to<const int>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
boost::pointer_traits<const R*>::rebind_to<int>::type>)); boost::pointer_traits<const R*>::rebind_to<int>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<int>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<int>,
boost::pointer_traits<P1<const R> >::rebind_to<int>::type>)); boost::pointer_traits<P1<const R> >::rebind_to<int>::type>));
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<char*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<char*,
boost::pointer_traits<R*>::rebind<char> >)); boost::pointer_traits<R*>::rebind<char> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<char>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<char>,
boost::pointer_traits<P1<R> >::rebind<char> >)); boost::pointer_traits<P1<R> >::rebind<char> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P2<char, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P2<char, R>,
boost::pointer_traits<P2<R, R> >::rebind<char> >)); boost::pointer_traits<P2<R, R> >::rebind<char> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P3<char, R, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P3<char, R, R>,
boost::pointer_traits<P3<R, R, R> >::rebind<char> >)); boost::pointer_traits<P3<R, R, R> >::rebind<char> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
boost::pointer_traits<R*>::rebind<void> >)); boost::pointer_traits<R*>::rebind<void> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<void>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<void>,
boost::pointer_traits<P1<R> >::rebind<void> >)); boost::pointer_traits<P1<R> >::rebind<void> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<R*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<R*,
boost::pointer_traits<void*>::rebind<R> >)); boost::pointer_traits<void*>::rebind<R> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<R>,
boost::pointer_traits<P1<void> >::rebind<R> >)); boost::pointer_traits<P1<void> >::rebind<R> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
boost::pointer_traits<R*>::rebind<const int> >)); boost::pointer_traits<R*>::rebind<const int> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<const int>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<const int>,
boost::pointer_traits<P1<R> >::rebind<const int> >)); boost::pointer_traits<P1<R> >::rebind<const int> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
boost::pointer_traits<const R*>::rebind<int> >)); boost::pointer_traits<const R*>::rebind<int> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<int>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<int>,
boost::pointer_traits<P1<const R> >::rebind<int> >)); boost::pointer_traits<P1<const R> >::rebind<int> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<R> >::rebind_to<char>::type>)); boost::pointer_traits<E1<R> >::rebind_to<char>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E2<bool, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E2<bool, R>,
boost::pointer_traits<E2<R, R> >::rebind_to<char>::type>)); boost::pointer_traits<E2<R, R> >::rebind_to<char>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E3<bool, R, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E3<bool, R, R>,
boost::pointer_traits<E3<R, R, R> >::rebind_to<char>::type>)); boost::pointer_traits<E3<R, R, R> >::rebind_to<char>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<R> >::rebind<char> >)); boost::pointer_traits<E1<R> >::rebind<char> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E2<bool, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E2<bool, R>,
boost::pointer_traits<E2<R, R> >::rebind<char> >)); boost::pointer_traits<E2<R, R> >::rebind<char> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E3<bool, R, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E3<bool, R, R>,
boost::pointer_traits<E3<R, R, R> >::rebind<char> >)); boost::pointer_traits<E3<R, R, R> >::rebind<char> >));
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<char, R, R, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<char, R, R, R>,
boost::pointer_traits<P<R, R, R, R> >::rebind<char> >)); boost::pointer_traits<P<R, R, R, R> >::rebind<char> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E<bool, R, R, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E<bool, R, R, R>,
boost::pointer_traits<E<R, R, R, R> >::rebind_to<char>::type>)); boost::pointer_traits<E<R, R, R, R> >::rebind_to<char>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E<bool, R, R, R>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E<bool, R, R, R>,
boost::pointer_traits<E<R, R, R, R> >::rebind<char> >)); boost::pointer_traits<E<R, R, R, R> >::rebind<char> >));
#endif #endif
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<R> >::rebind_to<void>::type>)); boost::pointer_traits<E1<R> >::rebind_to<void>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<void> >::rebind_to<R>::type>)); boost::pointer_traits<E1<void> >::rebind_to<R>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<R> >::rebind_to<const int>::type>)); boost::pointer_traits<E1<R> >::rebind_to<const int>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<const R> >::rebind_to<int>::type>)); boost::pointer_traits<E1<const R> >::rebind_to<int>::type>));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<R> >::rebind<void> >)); boost::pointer_traits<E1<R> >::rebind<void> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<void> >::rebind<R> >)); boost::pointer_traits<E1<void> >::rebind<R> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<R> >::rebind<const int> >)); boost::pointer_traits<E1<R> >::rebind<const int> >));
BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>, BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
boost::pointer_traits<E1<const R> >::rebind<int> >)); boost::pointer_traits<E1<const R> >::rebind<int> >));
#endif #endif
return boost::report_errors(); return boost::report_errors();

3
test/quick.cpp
View File

@ -16,13 +16,12 @@
#include <boost/core/explicit_operator_bool.hpp> #include <boost/core/explicit_operator_bool.hpp>
#include <boost/get_pointer.hpp> #include <boost/get_pointer.hpp>
#include <boost/core/ignore_unused.hpp> #include <boost/core/ignore_unused.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/noncopyable.hpp> #include <boost/noncopyable.hpp>
#include <boost/core/null_deleter.hpp> #include <boost/core/null_deleter.hpp>
#include <boost/core/fclose_deleter.hpp> #include <boost/core/fclose_deleter.hpp>
#include <boost/core/pointer_traits.hpp> #include <boost/core/pointer_traits.hpp>
#include <boost/ref.hpp> #include <boost/core/ref.hpp>
#include <boost/core/scoped_enum.hpp> #include <boost/core/scoped_enum.hpp>
#include <boost/core/typeinfo.hpp> #include <boost/core/typeinfo.hpp>
#include <boost/core/underlying_type.hpp> #include <boost/core/underlying_type.hpp>

12
test/ref_ct_test.cpp
View File

@ -6,10 +6,10 @@
// compile-time test for "boost/ref.hpp" header content // compile-time test for "boost/ref.hpp" header content
// see 'ref_test.cpp' for run-time part // see 'ref_test.cpp' for run-time part
#include <boost/ref.hpp> #include <boost/core/ref.hpp>
#include <boost/core/is_same.hpp>
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
#include <boost/config/workaround.hpp> #include <boost/config/workaround.hpp>
#include <boost/type_traits/is_same.hpp>
namespace { namespace {
@ -17,8 +17,8 @@ template< typename T, typename U >
void ref_test(boost::reference_wrapper<U>) void ref_test(boost::reference_wrapper<U>)
{ {
typedef typename boost::reference_wrapper<U>::type type; typedef typename boost::reference_wrapper<U>::type type;
BOOST_STATIC_ASSERT((boost::core::is_same<U,type>::value)); BOOST_STATIC_ASSERT((boost::is_same<U,type>::value));
BOOST_STATIC_ASSERT((boost::core::is_same<T,type>::value)); BOOST_STATIC_ASSERT((boost::is_same<T,type>::value));
} }
template< typename T > template< typename T >
@ -42,14 +42,14 @@ void is_reference_wrapper_test(T)
template< typename R, typename Ref > template< typename R, typename Ref >
void cxx_reference_test(Ref) void cxx_reference_test(Ref)
{ {
BOOST_STATIC_ASSERT((boost::core::is_same<R,Ref>::value)); BOOST_STATIC_ASSERT((boost::is_same<R,Ref>::value));
} }
template< typename R, typename Ref > template< typename R, typename Ref >
void unwrap_reference_test(Ref) void unwrap_reference_test(Ref)
{ {
typedef typename boost::unwrap_reference<Ref>::type type; typedef typename boost::unwrap_reference<Ref>::type type;
BOOST_STATIC_ASSERT((boost::core::is_same<R,type>::value)); BOOST_STATIC_ASSERT((boost::is_same<R,type>::value));
} }
} // namespace } // namespace

2
test/ref_test.cpp
View File

@ -6,7 +6,7 @@
// run-time test for "boost/ref.hpp" header content // run-time test for "boost/ref.hpp" header content
// see 'ref_ct_test.cpp' for compile-time part // see 'ref_ct_test.cpp' for compile-time part
#include <boost/ref.hpp> #include <boost/core/ref.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
namespace { namespace {

1
test/sv_types_test.cpp
View File

@ -5,7 +5,6 @@
#include <boost/core/detail/string_view.hpp> #include <boost/core/detail/string_view.hpp>
#include <boost/core/lightweight_test.hpp> #include <boost/core/lightweight_test.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/is_same.hpp>
#include <iterator> #include <iterator>
struct Ch struct Ch

6
test/underlying_type.cpp
View File

@ -15,7 +15,7 @@
#include <boost/core/underlying_type.hpp> #include <boost/core/underlying_type.hpp>
#include <boost/core/scoped_enum.hpp> #include <boost/core/scoped_enum.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
#include <boost/core/is_same.hpp> #include <boost/type_traits/is_same.hpp>
#include <boost/config.hpp> #include <boost/config.hpp>
#if defined(_MSC_VER) #if defined(_MSC_VER)
@ -63,9 +63,9 @@ struct underlying_type< native_enum >
int main(int, char*[]) int main(int, char*[])
{ {
BOOST_TEST_TRAIT_TRUE((boost::core::is_same< boost::underlying_type< emulated_enum >::type, unsigned char >)); BOOST_TEST_TRAIT_TRUE((boost::is_same< boost::underlying_type< emulated_enum >::type, unsigned char >));
#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) #if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
BOOST_TEST_TRAIT_TRUE((boost::core::is_same< boost::underlying_type< native_enum >::type, unsigned short >)); BOOST_TEST_TRAIT_TRUE((boost::is_same< boost::underlying_type< native_enum >::type, unsigned short >));
#endif #endif
return boost::report_errors(); return boost::report_errors();