Update serialization_construct_data_test

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,6 +59,7 @@ 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]
@@ -70,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/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/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) ;
@@ -359,5 +360,13 @@ 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/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();