Update serialization_construct_data_test

doc/changes.qbk

@@ -16,10 +16,12 @@
   or C++ standard library type traits instead.
 * Marked `boost::ref` member functions and associated methods with `noexcept`.
 * Marked `boost::swap` function with `noexcept`, depending on whether the type supports a non-throwing swap operation.
-* Added `boost::core::launder`, a portable implementation of `std::launder`.
-* Added `BOOST_CORE_ALIGNOF`, a portable implementation of `alignof`.
-* Added `boost::core::max_align_t`, a portable equivalent of `std::max_align_t`, and `boost::core::max_align`, the
-  alignment of `max_align_t`.
+* Added [link core.launder `boost::core::launder`], a portable implementation of `std::launder`.
+* Added [link core.alignof `BOOST_CORE_ALIGNOF`], a portable implementation of `alignof`.
+* Added [link core.max_align `boost::core::max_align_t`], a portable equivalent of `std::max_align_t`, and
+  `boost::core::max_align`, the alignment of `max_align_t`.
+* Added [link core.memory_resource `boost::core::memory_resource`], a portable equivalent of `std::pmr::memory_resource`
+  from C++17.
 
 [endsect]
 

doc/core.qbk

@@ -47,6 +47,7 @@ criteria for inclusion is that the utility component be:
 [include bit.qbk]
 [include checked_delete.qbk]
 [include cmath.qbk]
+[include data.qbk]
 [include default_allocator.qbk]
 [include demangle.qbk]
 [include empty_value.qbk]
@@ -58,7 +59,9 @@ criteria for inclusion is that the utility component be:
 [include is_same.qbk]
 [include launder.qbk]
 [include lightweight_test.qbk]
+[include make_span.qbk]
 [include max_align.qbk]
+[include memory_resource.qbk]
 [include no_exceptions_support.qbk]
 [include noinit_adaptor.qbk]
 [include noncopyable.qbk]
@@ -69,6 +72,7 @@ criteria for inclusion is that the utility component be:
 [include quick_exit.qbk]
 [include ref.qbk]
 [include scoped_enum.qbk]
+[include size.qbk]
 [include span.qbk]
 [include swap.qbk]
 [include typeinfo.qbk]

doc/data.qbk

@@ -0,0 +1,67 @@
+[/
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:data data]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/data.hpp> provides function templates `data`
+to obtain the pointer to the first element in a range.
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class C>
+constexpr auto
+data(C& c) noexcept(noexcept(c.data())) -> decltype(c.data());
+
+template<class C>
+constexpr auto
+data(const C& c) noexcept(noexcept(c.data())) -> decltype(c.data());
+
+template<class T, std::size_t N>
+constexpr T*
+data(T(&a)[N]) noexcept;
+
+template<class T>
+constexpr const T*
+data(std::initializer_list<T> l) noexcept;
+
+} /* boost */
+```
+
+[section Functions]
+
+[variablelist
+[[`template<class C> constexpr auto data(C& c) noexcept(noexcept(c.data())) ->
+decltype(c.data());`]
+[Returns `c.begin()`.]]
+[[`template<class C> constexpr auto data(const C& c)
+noexcept(noexcept(c.data())) -> decltype(c.data());`]
+[Returns `c.begin()`.]]
+[[`template<class T, std::size_t N> constexpr T* data(T(&a)[N]) noexcept;`]
+[Returns `a`.]]
+[[`template<class T> constexpr const T* data(std::initializer_list<T> l)
+noexcept;`]
+[Returns `l.begin()`.]]]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/make_span.qbk

@@ -0,0 +1,81 @@
+[/
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:make_span make_span]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/make_span.hpp> provides function templates `make_span`
+to conveniently create `span` objects. They are useful before C++17 where Class
+Template Argument Deduction (CTAD) is not available.
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class I>
+constexpr span<I>
+make_span(I* d, std::size_t n) noexcept;
+
+template<class I>
+constexpr span<I>
+make_span(I* b, I* e) noexcept;
+
+template<class T, std::size_t N>
+constexpr span<T, N>
+make_span(T(&a)[N]) noexcept;
+
+template<class T, std::size_t N>
+constexpr span<T, N>
+make_span(std::array<T, N>& a) noexcept;
+
+template<class T, std::size_t N>
+constexpr span<const T, N>
+make_span(const std::array<T, N>& a) noexcept;
+
+template<class R>
+span<remove_pointer_t<iterator_t<R> > >
+make_span(R&& r);
+
+} /* boost */
+```
+
+[section Functions]
+
+[variablelist
+[[`template<class I> span<I> make_span(I* f, std::size_t c);`]
+[Returns `span<I>(f, c)`.]]
+[[`template<class I> span<I> make_span(I* f, I* l);`]
+[Returns `span<I>(f, l)`.]]
+[[`template<class T, std::size_t N> span<T, N> make_span(T(&a)[N]);`]
+[Returns `span<T, N>(a)`.]]
+[[`template<class T, std::size_t N> span<T, N>
+make_span(std::array<T, N>& a);`]
+[Returns `span<T, N>(a)`.]]
+[[`template<class T, std::size_t N> span<const T, N>
+make_span(const std::array<T, N>& a);`]
+[Returns `span<const T, N>(a)`.]]
+[[`template<class R>
+span<remove_pointer_t<iterator_t<R> > >
+make_span(R&& r);`]
+[Returns `span<remove_pointer_t<iterator_t<R> > >(std::forward<R>(r))`.]]]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/max_align.qbk

@@ -29,7 +29,7 @@ namespace core
 
 union max_align_t;
 
-constexpr max_align = alignof(max_align_t);
+constexpr std::size_t max_align = alignof(max_align_t);
 
 } // namespace core
 } // namespace boost

doc/memory_resource.qbk

@@ -0,0 +1,139 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:memory_resource memory_resource]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/memory_resource.hpp>]
+
+The header `<boost/core/memory_resource.hpp>` defines the class
+`boost::core::memory_resource`, a portable equivalent of
+`std::pmr::memory_resource` from C++17.
+
+This is not a complete implementation of the standard `<memory_resource>`
+header; for such, one should use Boost.Container. The abstract base class
+is only provided by Core so that Boost libraries that provide and take
+advantage of PMR facilities such as concrete implementations of memory
+resources, or implementations of `polymorphic_allocator`, can interoperate.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+class memory_resource
+{
+public:
+
+    virtual ~memory_resource() = default;
+
+    [[nodiscard]] void* allocate( std::size_t bytes, std::size_t alignment = max_align );
+    void deallocate( void* p, std::size_t bytes, std::size_t alignment = max_align );
+
+    bool is_equal( memory_resource const & other ) const noexcept;
+
+private:
+
+    virtual void* do_allocate( std::size_t bytes, std::size_t alignment ) = 0;
+    virtual void do_deallocate( void* p, std::size_t bytes, std::size_t alignment ) = 0;
+
+    virtual bool do_is_equal( memory_resource const& other ) const noexcept = 0;
+};
+
+inline bool operator==( memory_resource const& a, memory_resource const& b ) noexcept;
+inline bool operator!=( memory_resource const& a, memory_resource const& b ) noexcept;
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[section `allocate`]
+
+`[[nodiscard]] void* allocate( std::size_t bytes, std::size_t alignment = max_align );`
+
+* *Returns:* `do_allocate( bytes, alignment )`.
+* *Remarks:* Implicitly creates objects in the returned region of storage.
+
+[endsect]
+
+[section `deallocate`]
+
+`void deallocate( void* p, std::size_t bytes, std::size_t alignment = max_align );`
+
+* *Effects:* `do_deallocate( bytes, alignment )`.
+
+[endsect]
+
+[section `is_equal`]
+
+`bool is_equal( memory_resource const& other ) const noexcept;`
+
+* *Returns:* `do_is_equal( other )`.
+
+[endsect]
+
+[section `do_allocate`]
+
+`void* do_allocate( std::size_t bytes, std::size_t alignment ) = 0;`
+
+* *Remarks:* A derived class should implement this member function to return
+  a pointer to allocated storage of size at least `bytes` and alignment at
+  least `alignment`.
+* *Throws:* An appropriate exception (by convention `std::bad_alloc` or
+  derived) when storage with the specified size and alignment could not be
+  obtained.
+
+[endsect]
+
+[section `do_deallocate`]
+
+`void do_deallocate( void* p, std::size_t bytes, std::size_t alignment ) = 0;`
+
+* *Remarks:* A derived class should implement this member function to deallocate
+  a region of storage previously allocated by `do_allocate`.
+* *Throws:* Nothing.
+
+[endsect]
+
+[section `do_is_equal`]
+
+`bool do_is_equal( memory_resource const& other ) const noexcept = 0;`
+
+* *Remarks:* A derived class shall implement this function to return `true` if
+  memory allocated from `*this` can be deallocated from `other` and vice-versa,
+  otherwise `false`.
+
+[endsect]
+
+[section `operator==`]
+
+`bool operator==( memory_resource const& a, memory_resource const& b ) noexcept;`
+
+* *Returns:* `&a == &b || a.is_equal( b )`.
+
+[endsect]
+
+[section `operator!=`]
+
+`bool operator!=( memory_resource const& a, memory_resource const& b ) noexcept;`
+
+* *Returns:* `!( a == b )`.
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/size.qbk

@@ -0,0 +1,54 @@
+[/
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:size size]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/size.hpp> provides function templates `size` to obtain
+the number of elements in a range.
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class C>
+constexpr auto
+size(const C& c) noexcept(noexcept(c.size())) -> decltype(c.size());
+
+template<class T, std::size_t N>
+constexpr std::size_t
+size(T(&)[N]) noexcept;
+
+} /* boost */
+```
+
+[section Functions]
+
+[variablelist
+[[`template<class C> constexpr auto size(const C& c)
+noexcept(noexcept(c.size())) -> decltype(c.size());`]
+[Returns `c.size()`.]]
+[[`template<class T, std::size_t N> constexpr std::size_t size(T(&)[N])
+noexcept;`]
+[Returns `N`.]]]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/span.qbk

@@ -149,7 +149,7 @@ template<class T, std::size_t N>
 span(const std::array<T, N>&) -> span<const T, N>;
 
 template<class R>
-span(R&&) -> span<std::remove_pointer_t<decltype(std::declval<R&>().data())> >;
+span(R&&) -> span<remove_pointer_t<iterator_t<R> > >;
 
 template<class T, std::size_t E>
 span<const std::byte, E == dynamic_extent ? dynamic_extent : sizeof(T) * E>
@@ -228,7 +228,7 @@ constexpr span(R&& r);`]
 [`remove_cvref_t<R>` is not a specialization of `array`,]
 [`is_array_v<remove_cvref_t<R>>` is `false`,]
 [`r.data()` is well-formed and
-`is_convertible_v<remove_pointer_t<decltype(declval<R&>().data())>(*)[],
+`is_convertible_v<remove_pointer_t<iterator_t<R> >(*)[],
 T(*)[]>` is `true`, and]
 [`r.size()` is well-formed and
 `is_convertible_v<decltype(declval<R&>().size()), size_t>` is `true`.]]]]

include/boost/core/data.hpp

@@ -0,0 +1,46 @@
+/*
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_DATA_HPP
+#define BOOST_CORE_DATA_HPP
+
+#include <initializer_list>
+#include <cstddef>
+
+namespace boost {
+
+template<class C>
+inline constexpr auto
+data(C& c) noexcept(noexcept(c.data())) -> decltype(c.data())
+{
+    return c.data();
+}
+
+template<class C>
+inline constexpr auto
+data(const C& c) noexcept(noexcept(c.data())) -> decltype(c.data())
+{
+    return c.data();
+}
+
+template<class T, std::size_t N>
+inline constexpr T*
+data(T(&a)[N]) noexcept
+{
+    return a;
+}
+
+template<class T>
+inline constexpr const T*
+data(std::initializer_list<T> l) noexcept
+{
+    return l.begin();
+}
+
+} /* boost */
+
+#endif

include/boost/core/make_span.hpp

@@ -0,0 +1,59 @@
+/*
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_MAKE_SPAN_HPP
+#define BOOST_CORE_MAKE_SPAN_HPP
+
+#include <boost/core/span.hpp>
+
+namespace boost {
+
+template<class I>
+inline constexpr span<I>
+make_span(I* f, std::size_t c) noexcept
+{
+    return span<I>(f, c);
+}
+
+template<class I>
+inline constexpr span<I>
+make_span(I* f, I* l) noexcept
+{
+    return span<I>(f, l);
+}
+
+template<class T, std::size_t N>
+inline constexpr span<T, N>
+make_span(T(&a)[N]) noexcept
+{
+    return span<T, N>(a);
+}
+
+template<class T, std::size_t N>
+inline constexpr span<T, N>
+make_span(std::array<T, N>& a) noexcept
+{
+    return span<T, N>(a);
+}
+
+template<class T, std::size_t N>
+inline constexpr span<const T, N>
+make_span(const std::array<T, N>& a) noexcept
+{
+    return span<const T, N>(a);
+}
+
+template<class R>
+inline span<typename detail::span_data<R>::type>
+make_span(R&& r)
+{
+    return span<typename detail::span_data<R>::type>(std::forward<R>(r));
+}
+
+} /* boost */
+
+#endif

include/boost/core/memory_resource.hpp

@@ -0,0 +1,108 @@
+#ifndef BOOST_CORE_MEMORY_RESOURCE_HPP_INCLUDED
+#define BOOST_CORE_MEMORY_RESOURCE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/max_align.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <cstddef>
+
+// Define our own placement new to avoid the inclusion of <new>
+// (~9K extra lines) at Ion Gaztanhaga's request.
+//
+// We can use our own because [intro.object] p13 says:
+//
+// Any implicit or explicit invocation of a function named `operator new`
+// or `operator new[]` implicitly creates objects in the returned region of
+// storage and returns a pointer to a suitable created object.
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+struct placement_new_tag {};
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+inline void* operator new( std::size_t, void* p, boost::core::detail::placement_new_tag )
+{
+    return p;
+}
+
+inline void operator delete( void*, void*, boost::core::detail::placement_new_tag )
+{
+}
+
+namespace boost
+{
+namespace core
+{
+
+class memory_resource
+{
+public:
+
+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
+    virtual ~memory_resource() {}
+
+#else
+
+    virtual ~memory_resource() = default;
+
+#endif
+
+    BOOST_ATTRIBUTE_NODISCARD void* allocate( std::size_t bytes, std::size_t alignment = max_align )
+    {
+        // https://github.com/boostorg/container/issues/199
+        // https://cplusplus.github.io/LWG/issue3471
+
+        return ::operator new( bytes, do_allocate( bytes, alignment ), core::detail::placement_new_tag() );
+    }
+
+    void deallocate( void* p, std::size_t bytes, std::size_t alignment = max_align )
+    {
+        do_deallocate( p, bytes, alignment );
+    }
+
+    bool is_equal( memory_resource const & other ) const BOOST_NOEXCEPT
+    {
+        return do_is_equal( other );
+    }
+
+private:
+
+    virtual void* do_allocate( std::size_t bytes, std::size_t alignment ) = 0;
+    virtual void do_deallocate( void* p, std::size_t bytes, std::size_t alignment ) = 0;
+
+    virtual bool do_is_equal( memory_resource const & other ) const BOOST_NOEXCEPT = 0;
+};
+
+inline bool operator==( memory_resource const& a, memory_resource const& b ) BOOST_NOEXCEPT
+{
+    return &a == &b || a.is_equal( b );
+}
+
+inline bool operator!=( memory_resource const& a, memory_resource const& b ) BOOST_NOEXCEPT
+{
+    return !( a == b );
+}
+
+} // namespace core
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_MEMORY_RESOURCE_HPP_INCLUDED

include/boost/core/serialization.hpp

@@ -0,0 +1,131 @@
+#ifndef BOOST_CORE_SERIALIZATION_HPP_INCLUDED
+#define BOOST_CORE_SERIALIZATION_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+//
+// Utilities needed to implement serialization support
+// without including a Boost.Serialization header
+
+#include <boost/core/nvp.hpp>
+#include <cstddef>
+
+namespace boost
+{
+
+namespace serialization
+{
+
+// Forward declarations (needed for specializations)
+
+template<class T> struct version;
+
+class access;
+
+// Our own version_type replacement. This has to be in
+// the `serialization` namespace, because its only purpose
+// is to add `serialization` as an associated namespace.
+
+struct core_version_type
+{
+    unsigned int version_;
+
+    core_version_type( unsigned int version ): version_( version ) {}
+    operator unsigned int () const { return version_; }
+};
+
+} // namespace serialization
+
+namespace core
+{
+
+// nvp
+
+using serialization::nvp;
+using serialization::make_nvp;
+
+// split_free
+
+namespace detail
+{
+
+template<bool IsSaving> struct load_or_save_f;
+
+template<> struct load_or_save_f<true>
+{
+    template<class A, class T> void operator()( A& a, T& t, unsigned int v ) const
+    {
+        save( a, t, serialization::core_version_type( v ) );
+    }
+};
+
+template<> struct load_or_save_f<false>
+{
+    template<class A, class T> void operator()( A& a, T& t, unsigned int v ) const
+    {
+        load( a, t, serialization::core_version_type( v ) );
+    }
+};
+
+} // namespace detail
+
+template<class A, class T> inline void split_free( A& a, T& t, unsigned int v )
+{
+    detail::load_or_save_f< A::is_saving::value >()( a, t, v );
+}
+
+// split_member
+
+namespace detail
+{
+
+template<bool IsSaving, class Access = serialization::access> struct load_or_save_m;
+
+template<class Access> struct load_or_save_m<true, Access>
+{
+    template<class A, class T> void operator()( A& a, T const& t, unsigned int v ) const
+    {
+        Access::member_save( a, t, v );
+    }
+};
+
+template<class Access> struct load_or_save_m<false, Access>
+{
+    template<class A, class T> void operator()( A& a, T& t, unsigned int v ) const
+    {
+        Access::member_load( a, t, v );
+    }
+};
+
+} // namespace detail
+
+template<class A, class T> inline void split_member( A& a, T& t, unsigned int v )
+{
+    detail::load_or_save_m< A::is_saving::value >()( a, t, v );
+}
+
+// load_construct_data_adl
+
+template<class Ar, class T> void load_construct_data_adl( Ar& ar, T* t, unsigned int v )
+{
+    load_construct_data( ar, t, serialization::core_version_type( v ) );
+}
+
+// save_construct_data_adl
+
+template<class Ar, class T> void save_construct_data_adl( Ar& ar, T const* t, unsigned int v )
+{
+    save_construct_data( ar, t, serialization::core_version_type( v ) );
+}
+
+} // namespace core
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_SERIALIZATION_HPP_INCLUDED

include/boost/core/size.hpp

@@ -0,0 +1,31 @@
+/*
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_SIZE_HPP
+#define BOOST_CORE_SIZE_HPP
+
+#include <cstddef>
+
+namespace boost {
+
+template<class C>
+inline constexpr auto
+size(const C& c) noexcept(noexcept(c.size())) -> decltype(c.size())
+{
+    return c.size();
+}
+
+template<class T, std::size_t N>
+inline constexpr std::size_t
+size(T(&)[N]) noexcept
+{
+    return N;
+}
+
+} /* boost */
+
+#endif

include/boost/core/span.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Glen Joseph Fernandes
+Copyright 2019-2023 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -9,6 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #define BOOST_CORE_SPAN_HPP
 
 #include <array>
+#include <initializer_list>
 #include <iterator>
 #include <type_traits>
 #include <cstddef>
@@ -39,10 +40,8 @@ struct span_compatible {
 };
 
 template<class T>
-struct span_uncvref {
-    typedef typename std::remove_cv<typename
-        std::remove_reference<T>::type>::type type;
-};
+using span_uncvref = typename std::remove_cv<typename
+    std::remove_reference<T>::type>::type;
 
 template<class>
 struct span_is_span {
@@ -64,15 +63,37 @@ struct span_is_array<std::array<T, N> > {
     static constexpr bool value = true;
 };
 
+template<class C>
+inline constexpr auto
+span_begin(C& c) noexcept(noexcept(c.data())) -> decltype(c.data())
+{
+    return c.data();
+}
+
+template<class C>
+inline constexpr auto
+span_begin(const C& c) noexcept(noexcept(c.data())) -> decltype(c.data())
+{
+    return c.data();
+}
+
+template<class T>
+inline constexpr const T*
+span_begin(std::initializer_list<T> l) noexcept
+{
+    return l.begin();
+}
+
+template<class T>
+using span_ptr = decltype(boost::detail::span_begin(std::declval<T&>()));
+
 template<class, class = void>
 struct span_data { };
 
 template<class T>
 struct span_data<T,
-    typename std::enable_if<std::is_pointer<decltype(std::declval<T
-        &>().data())>::value>::type> {
-    typedef typename std::remove_pointer<decltype(std::declval<T
-        &>().data())>::type type;
+    typename std::enable_if<std::is_pointer<span_ptr<T> >::value>::type> {
+    typedef typename std::remove_pointer<span_ptr<T> >::type type;
 };
 
 template<class, class, class = void>
@@ -102,9 +123,9 @@ template<class R, class T>
 struct span_is_range {
     static constexpr bool value = (std::is_const<T>::value ||
         std::is_lvalue_reference<R>::value) &&
-        !span_is_span<typename span_uncvref<R>::type>::value &&
-        !span_is_array<typename span_uncvref<R>::type>::value &&
-        !std::is_array<typename span_uncvref<R>::type>::value &&
+        !span_is_span<span_uncvref<R> >::value &&
+        !span_is_array<span_uncvref<R> >::value &&
+        !std::is_array<span_uncvref<R> >::value &&
         span_has_data<R, T>::value &&
         span_has_size<R>::value;
 };
@@ -224,15 +245,16 @@ public:
     template<class R,
         typename std::enable_if<E == dynamic_extent &&
             detail::span_is_range<R, T>::value, int>::type = 0>
-    constexpr span(R&& r) noexcept(noexcept(r.data()) && noexcept(r.size()))
-        : s_(r.data(), r.size()) { }
+    constexpr span(R&& r) noexcept(noexcept(detail::span_begin(r)) &&
+        noexcept(r.size()))
+        : s_(detail::span_begin(r), r.size()) { }
 
     template<class R,
         typename std::enable_if<E != dynamic_extent &&
             detail::span_is_range<R, T>::value, int>::type = 0>
-    explicit constexpr span(R&& r) noexcept(noexcept(r.data()) &&
+    explicit constexpr span(R&& r) noexcept(noexcept(detail::span_begin(r)) &&
         noexcept(r.size()))
-        : s_(r.data(), r.size()) { }
+        : s_(detail::span_begin(r), r.size()) { }
 
     template<class U, std::size_t N,
         typename std::enable_if<detail::span_implicit<E, N>::value &&

test/CMakeLists.txt

@@ -31,6 +31,13 @@ set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::config Boost::move Boost::smart
 
 boost_test(TYPE run SOURCES fclose_deleter_test.cpp)
 
+set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::serialization)
+
+boost_test(TYPE run SOURCES serialization_nvp_test.cpp)
+boost_test(TYPE run SOURCES serialization_split_free_test.cpp)
+boost_test(TYPE run SOURCES serialization_split_member_test.cpp)
+boost_test(TYPE run SOURCES serialization_construct_data_test.cpp)
+
 endif()
 
 add_subdirectory(swap)

test/Jamfile.v2

@@ -343,6 +343,7 @@ run span_deduction_guide_test.cpp ;
 run as_bytes_test.cpp ;
 run as_writable_bytes_test.cpp ;
 compile span_boost_begin_test.cpp ;
+run make_span_test.cpp ;
 
 run splitmix64_test.cpp
   : : : $(pedantic-errors) ;
@@ -357,5 +358,15 @@ run launder_test.cpp ;
 run alignof_test.cpp ;
 run max_align_test.cpp ;
 
+run memory_resource_test.cpp ;
+
+run data_test.cpp ;
+run size_test.cpp ;
+
+run serialization_nvp_test.cpp : : : <library>/boost//serialization/<warnings>off <toolset>clang,<undefined-sanitizer>norecover:<build>no ;
+run serialization_split_free_test.cpp : : : <library>/boost//serialization/<warnings>off ;
+run serialization_split_member_test.cpp : : : <library>/boost//serialization/<warnings>off ;
+run serialization_construct_data_test.cpp : : : <library>/boost//serialization/<warnings>off ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/data_test.cpp

@@ -0,0 +1,68 @@
+/*
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
+#include <boost/core/data.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class range {
+public:
+    int* data() {
+        return &v_[0];
+    }
+
+    const int* data() const {
+        return &v_[0];
+    }
+
+    std::size_t size() const {
+        return 4;
+    }
+
+private:
+    int v_[4];
+};
+
+void test_range()
+{
+    range c;
+    BOOST_TEST_EQ(boost::data(c), c.data());
+}
+
+void test_const_range()
+{
+    const range c = range();
+    BOOST_TEST_EQ(boost::data(c), c.data());
+}
+
+void test_array()
+{
+    int a[4];
+    BOOST_TEST_EQ(boost::data(a), a);
+}
+
+void test_initializer_list()
+{
+    std::initializer_list<int> l{1, 2, 3, 4};
+    BOOST_TEST_EQ(boost::data(l), l.begin());
+}
+
+int main()
+{
+    test_range();
+    test_const_range();
+    test_array();
+    test_initializer_list();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/make_span_test.cpp

@@ -0,0 +1,100 @@
+/*
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
+#include <boost/core/make_span.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class T>
+class range {
+public:
+    T* data() {
+        return &v_[0];
+    }
+
+    std::size_t size() const {
+        return 4;
+    }
+
+private:
+    T v_[4];
+};
+
+void test_data_size()
+{
+    int a[4];
+    boost::span<int> s = boost::make_span(&a[0], 4);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_first_last()
+{
+    int a[4];
+    boost::span<int> s = boost::make_span(&a[0], &a[4]);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_array()
+{
+    int a[4];
+    boost::span<int, 4> s = boost::make_span(a);
+    BOOST_TEST_EQ(s.data(), &a[0]);
+    BOOST_TEST_EQ(s.size(), 4);
+}
+
+void test_std_array()
+{
+    std::array<int, 4> a;
+    boost::span<int, 4> s = boost::make_span(a);
+    BOOST_TEST_EQ(s.data(), a.data());
+    BOOST_TEST_EQ(s.size(), a.size());
+}
+
+void test_const_std_array()
+{
+    const std::array<int, 4> a = std::array<int, 4>();
+    boost::span<const int> s = boost::make_span(a);
+    BOOST_TEST_EQ(s.data(), a.data());
+    BOOST_TEST_EQ(s.size(), a.size());
+}
+
+void test_range()
+{
+    range<int> c;
+    boost::span<int> s = boost::make_span(c);
+    BOOST_TEST_EQ(s.data(), c.data());
+    BOOST_TEST_EQ(s.size(), c.size());
+}
+
+void test_initializer_list()
+{
+    std::initializer_list<int> l{1, 2};
+    boost::span<const int> s = boost::make_span(l);
+    BOOST_TEST_EQ(s.data(), l.begin());
+    BOOST_TEST_EQ(s.size(), l.size());
+}
+
+int main()
+{
+    test_data_size();
+    test_first_last();
+    test_array();
+    test_std_array();
+    test_const_std_array();
+    test_range();
+    test_initializer_list();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/memory_resource_test.cpp

@@ -0,0 +1,141 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/memory_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <new>
+#include <cstddef>
+
+static bool do_allocate_called;
+static std::size_t do_allocate_bytes;
+static std::size_t do_allocate_alignment;
+
+static bool do_deallocate_called;
+static void* do_deallocate_p;
+static std::size_t do_deallocate_bytes;
+static std::size_t do_deallocate_alignment;
+
+struct R1: public boost::core::memory_resource
+{
+    void* do_allocate( std::size_t bytes, std::size_t alignment )
+    {
+        do_allocate_called = true;
+        do_allocate_bytes = bytes;
+        do_allocate_alignment = alignment;
+
+        return ::operator new( bytes );
+    }
+
+    void do_deallocate( void* p, std::size_t bytes, std::size_t alignment )
+    {
+        do_deallocate_called = true;
+        do_deallocate_p = p;
+        do_deallocate_bytes = bytes;
+        do_deallocate_alignment = alignment;
+
+        ::operator delete( p );
+    }
+
+    bool do_is_equal( memory_resource const & /*other*/ ) const BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+struct R2: public boost::core::memory_resource
+{
+    void* do_allocate( std::size_t bytes, std::size_t /*alignment*/ )
+    {
+        return ::operator new( bytes );
+    }
+
+    void do_deallocate( void* p, std::size_t /*bytes*/, std::size_t /*alignment*/ )
+    {
+        ::operator delete( p );
+    }
+
+    bool do_is_equal( memory_resource const & other ) const BOOST_NOEXCEPT
+    {
+        return this == &other;
+    }
+};
+
+int main()
+{
+    {
+        R1 r1;
+
+        do_allocate_called = false;
+        do_allocate_bytes = 0;
+        do_allocate_alignment = 0;
+
+        void* p = r1.allocate( 31 );
+
+        BOOST_TEST( do_allocate_called );
+        BOOST_TEST_EQ( do_allocate_bytes, 31 );
+        BOOST_TEST_EQ( do_allocate_alignment, boost::core::max_align );
+
+        do_deallocate_called = false;
+        do_deallocate_p = 0;
+        do_deallocate_bytes = 0;
+        do_deallocate_alignment = 0;
+
+        r1.deallocate( p, 31 );
+
+        BOOST_TEST( do_deallocate_called );
+        BOOST_TEST_EQ( do_deallocate_p, p );
+        BOOST_TEST_EQ( do_deallocate_bytes, 31 );
+        BOOST_TEST_EQ( do_deallocate_alignment, boost::core::max_align );
+    }
+
+    {
+        R1 r1;
+
+        do_allocate_called = false;
+        do_allocate_bytes = 0;
+        do_allocate_alignment = 0;
+
+        void* p = r1.allocate( 1, 8 );
+
+        BOOST_TEST( do_allocate_called );
+        BOOST_TEST_EQ( do_allocate_bytes, 1 );
+        BOOST_TEST_EQ( do_allocate_alignment, 8 );
+
+        do_deallocate_called = false;
+        do_deallocate_p = 0;
+        do_deallocate_bytes = 0;
+        do_deallocate_alignment = 0;
+
+        r1.deallocate( p, 1, 8 );
+
+        BOOST_TEST( do_deallocate_called );
+        BOOST_TEST_EQ( do_deallocate_p, p );
+        BOOST_TEST_EQ( do_deallocate_bytes, 1 );
+        BOOST_TEST_EQ( do_deallocate_alignment, 8 );
+    }
+
+    {
+        R1 r1;
+        R1 r2;
+
+        BOOST_TEST( r1 == r1 );
+        BOOST_TEST_NOT( r1 != r1 );
+
+        BOOST_TEST( r1 == r2 );
+        BOOST_TEST_NOT( r1 != r2 );
+    }
+
+    {
+        R2 r1;
+        R2 r2;
+
+        BOOST_TEST( r1 == r1 );
+        BOOST_TEST_NOT( r1 != r1 );
+
+        BOOST_TEST_NOT( r1 == r2 );
+        BOOST_TEST( r1 != r2 );
+    }
+
+    return boost::report_errors();
+}

test/serialization_construct_data_test.cpp

@@ -0,0 +1,102 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wdeprecated-copy" )
+#  pragma clang diagnostic ignored "-Wdeprecated-copy"
+# endif
+#endif
+
+#include <boost/core/serialization.hpp>
+#include <new>
+
+struct X
+{
+    int v_;
+    explicit X( int v ): v_( v ) {}
+
+    template<class Ar> void serialize( Ar& /*ar*/, unsigned /*v*/ )
+    {
+    }
+};
+
+template<class Ar> void save_construct_data( Ar& ar, X const* t, unsigned /*v*/ )
+{
+    ar << t->v_;
+}
+
+template<class Ar> void load_construct_data( Ar& ar, X* t, unsigned /*v*/ )
+{
+    int v;
+    ar >> v;
+
+    ::new( t ) X( v );
+}
+
+struct Y
+{
+    X x1, x2;
+
+    explicit Y( int v1, int v2 ): x1( v1 ), x2( v2 ) {}
+
+private:
+
+    friend class boost::serialization::access;
+
+    template<class Ar> void load( Ar& ar, unsigned v )
+    {
+        boost::core::load_construct_data_adl( ar, &x1, v );
+        ar >> x1;
+
+        boost::core::load_construct_data_adl( ar, &x2, v );
+        ar >> x2;
+    }
+
+    template<class Ar> void save( Ar& ar, unsigned v ) const
+    {
+        boost::core::save_construct_data_adl( ar, &x1, v );
+        ar << x1;
+
+        boost::core::save_construct_data_adl( ar, &x2, v );
+        ar << x2;
+    }
+
+    template<class Ar> void serialize( Ar& ar, unsigned v )
+    {
+        boost::core::split_member( ar, *this, v );
+    }
+};
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+#include <string>
+
+int main()
+{
+    std::ostringstream os;
+
+    Y y1( 7, 11 );
+
+    {
+        boost::archive::text_oarchive ar( os );
+        ar << y1;
+    }
+
+    std::string s = os.str();
+
+    Y y2( 0, 0 );
+
+    {
+        std::istringstream is( s );
+        boost::archive::text_iarchive ar( is );
+        ar >> y2;
+    }
+
+    BOOST_TEST_EQ( y1.x1.v_, y2.x1.v_ );
+    BOOST_TEST_EQ( y1.x2.v_, y2.x2.v_ );
+
+    return boost::report_errors();
+}

test/serialization_nvp_test.cpp

@@ -0,0 +1,55 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wdeprecated-copy" )
+#  pragma clang diagnostic ignored "-Wdeprecated-copy"
+# endif
+#endif
+
+#include <boost/core/serialization.hpp>
+
+struct X
+{
+    int a, b;
+
+    template<class Ar> void serialize( Ar& ar, unsigned /*v*/ )
+    {
+        ar & boost::core::make_nvp( "a", a );
+        ar & boost::core::make_nvp( "b", b );
+    }
+};
+
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+#include <string>
+
+int main()
+{
+    std::ostringstream os;
+
+    X x1 = { 7, 11 };
+
+    {
+        boost::archive::xml_oarchive ar( os );
+        ar << boost::core::make_nvp( "x1", x1 );
+    }
+
+    std::string s = os.str();
+
+    X x2 = { 0, 0 };
+
+    {
+        std::istringstream is( s );
+        boost::archive::xml_iarchive ar( is );
+        ar >> boost::make_nvp( "x2", x2 );
+    }
+
+    BOOST_TEST_EQ( x1.a, x2.a );
+    BOOST_TEST_EQ( x1.b, x2.b );
+
+    return boost::report_errors();
+}

test/serialization_split_free_test.cpp

@@ -0,0 +1,66 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wdeprecated-copy" )
+#  pragma clang diagnostic ignored "-Wdeprecated-copy"
+# endif
+#endif
+
+#include <boost/core/serialization.hpp>
+
+struct X
+{
+    int a, b;
+};
+
+template<class Ar> void load( Ar& ar, X& x, unsigned /*v*/ )
+{
+    ar >> x.a;
+    ar >> x.b;
+}
+
+template<class Ar> void save( Ar& ar, X const& x, unsigned /*v*/ )
+{
+    ar << x.a;
+    ar << x.b;
+}
+
+template<class Ar> void serialize( Ar& ar, X& x, unsigned v )
+{
+    boost::core::split_free( ar, x, v );
+}
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+#include <string>
+
+int main()
+{
+    std::ostringstream os;
+
+    X x1 = { 7, 11 };
+
+    {
+        boost::archive::text_oarchive ar( os );
+        ar << x1;
+    }
+
+    std::string s = os.str();
+
+    X x2 = { 0, 0 };
+
+    {
+        std::istringstream is( s );
+        boost::archive::text_iarchive ar( is );
+        ar >> x2;
+    }
+
+    BOOST_TEST_EQ( x1.a, x2.a );
+    BOOST_TEST_EQ( x1.b, x2.b );
+
+    return boost::report_errors();
+}

test/serialization_split_member_test.cpp

@@ -0,0 +1,70 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wdeprecated-copy" )
+#  pragma clang diagnostic ignored "-Wdeprecated-copy"
+# endif
+#endif
+
+#include <boost/core/serialization.hpp>
+
+struct X
+{
+    int a, b;
+
+private:
+
+    friend class boost::serialization::access;
+
+    template<class Ar> void load( Ar& ar, unsigned /*v*/ )
+    {
+        ar >> a;
+        ar >> b;
+    }
+
+    template<class Ar> void save( Ar& ar, unsigned /*v*/ ) const
+    {
+        ar << a;
+        ar << b;
+    }
+
+    template<class Ar> void serialize( Ar& ar, unsigned v )
+    {
+        boost::core::split_member( ar, *this, v );
+    }
+};
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+#include <string>
+
+int main()
+{
+    std::ostringstream os;
+
+    X x1 = { 7, 11 };
+
+    {
+        boost::archive::text_oarchive ar( os );
+        ar << x1;
+    }
+
+    std::string s = os.str();
+
+    X x2 = { 0, 0 };
+
+    {
+        std::istringstream is( s );
+        boost::archive::text_iarchive ar( is );
+        ar >> x2;
+    }
+
+    BOOST_TEST_EQ( x1.a, x2.a );
+    BOOST_TEST_EQ( x1.b, x2.b );
+
+    return boost::report_errors();
+}

test/size_test.cpp

@@ -0,0 +1,42 @@
+/*
+Copyright 2023 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
+#include <boost/core/size.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct range {
+    std::size_t size() const {
+        return 4;
+    }
+};
+
+void test_range()
+{
+    range c;
+    BOOST_TEST_EQ(boost::size(c), 4);
+}
+
+void test_array()
+{
+    int a[4];
+    BOOST_TEST_EQ(boost::size(a), 4);
+}
+
+int main()
+{
+    test_range();
+    test_array();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/span_constructible_test.cpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Glen Joseph Fernandes
+Copyright 2019-2023 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -140,6 +140,14 @@ void test_range()
         range<derived>&>));
 }
 
+void test_initializer_list()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
+        std::initializer_list<int> >));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        std::initializer_list<int> >));
+}
+
 void test_span()
 {
     BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
@@ -187,6 +195,7 @@ int main()
     test_std_array();
     test_const_std_array();
     test_range();
+    test_initializer_list();
     test_span();
     test_copy();
     test_assign();

test/span_deduction_guide_test.cpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Glen Joseph Fernandes
+Copyright 2019-2023 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -78,6 +78,15 @@ void test_range()
     BOOST_TEST_EQ(s.size(), c.size());
 }
 
+void test_initializer_list()
+{
+    std::initializer_list<int> l{1, 2};
+    boost::span s(l);
+    BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
+    BOOST_TEST_EQ(s.data(), l.begin());
+    BOOST_TEST_EQ(s.size(), l.size());
+}
+
 void test_span_dynamic()
 {
     int a[4];
@@ -104,6 +113,7 @@ int main()
     test_std_array();
     test_const_std_array();
     test_range();
+    test_initializer_list();
     test_span_dynamic();
     test_span_static();
     return boost::report_errors();

test/span_test.cpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Glen Joseph Fernandes
+Copyright 2019-2023 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -118,6 +118,14 @@ void test_construct_range()
     BOOST_TEST_EQ(s.size(), c.size());
 }
 
+void test_construct_initializer_list()
+{
+    std::initializer_list<int> l{1, 2};
+    boost::span<const int> s(l);
+    BOOST_TEST_EQ(s.data(), l.begin());
+    BOOST_TEST_EQ(s.size(), l.size());
+}
+
 void test_construct_span_dynamic()
 {
     int a[4];
@@ -376,6 +384,7 @@ int main()
     test_construct_const_std_array_dynamic();
     test_construct_const_std_array_static();
     test_construct_range();
+    test_construct_initializer_list();
     test_construct_span_dynamic();
     test_construct_span_dynamic_static();
     test_construct_span_static();