enable conversion for derived described structs

Author: grisumbras

CHANGELOG.adoc

@@ -5,6 +5,11 @@
 
 include::doc/pages/definitions.adoc[]
 
+== Boost 1.89.0
+
+.API Changes
+* {issue}1086[#1086] Described class support is enabled for types with bases.
+
 == Boost 1.87.0
 
 .API Changes
@@ -13,7 +18,6 @@ include::doc/pages/definitions.adoc[]
 * {issue}1040[#1040] Deprecated initilaizer list behavior was removed.
 * {issue}1040[#1040] Deprecated type aliases were removed.
 
-
 .New Features
 * {issue}956[#956] <<direct_conversion,Direct serialization>>.
 * {issue}644[#644] Add GDB pretty printers for Boost.JSON types.

include/boost/json/conversion.hpp

@@ -280,26 +280,29 @@ struct is_null_like
 /** Determine if `T` should be treated as a described class.
 
     Described classes are serialised as objects with an element for each
-    described data member. A described class should not have described bases or
-    non-public members.
+    described data member. Described bases are serialized in a flattened way,
+    that is members of bases are serialized as direct elements of the object,
+    and no nested objects are created for bases.
 
-    Or more formally, given `L`, a class template of the form
-    `template<class...> struct L {};`, if
+    A described class should not have non-public described members (including
+    inherited members) or non-public non-empty described bases. Or more
+    formally, given `L`, a class template of the form
+    `template<class...> struct L {}`, if
 
-    - `boost::describe::has_members<T, boost::describe::mod_public>::value` is
-      `true`; and
+    - `boost::describe::has_describe_members<T>::value` is `true`; and
 
     - `boost::describe::describe_members<T, boost::describe::mod_private |
-      boost::describe::mod_protected>` denotes `L<>`; and
-
-    - `boost::describe::describe_bases<T, boost::describe::mod_any_access>`
-      denotes `L<>`; and
+      boost::describe::mod_protected | boost::describe::mod_inherited>` denotes
+      `L<>`; and
 
     - `std::is_union<T>::value` is `false`;
 
     then the trait provides the member constant `value` that is equal to
     `true`. Otherwise, `value` is equal to `false`.
 
+    @note Shadowed members are ignored both for requirements checking and for
+    performing conversions.
+
     Users can specialize the trait for their own types if they don't want them
     to be treated as described classes. For example:
 
@@ -316,10 +319,8 @@ struct is_null_like
     @endcode
 
     Users can also specialize the trait for their own types _with_ described
-    bases or described non-public data members to enable this conversion
-    implementation. In this case the class will be serialized in a flattened
-    way, that is members of bases will be serialized as direct elements of the
-    object, and no nested objects will be created for bases.
+    non-public data members to enable this conversion implementation. Note that
+    non-public bases are not supported regardless.
 
     @see [Boost.Describe](https://www.boost.org/doc/libs/develop/libs/describe/doc/html/describe.html).
 */

include/boost/json/detail/parse_into.hpp

@@ -1130,6 +1130,10 @@ class converting_handler<described_class_conversion_tag, V, P>
 #else
 
 private:
+    static_assert(
+        uniquely_named_members<V>::value,
+        "The type has several described members with the same name.");
+
     using Dm = described_members<V>;
     using Dt = struct_element_list<V>;
 

include/boost/json/detail/value_from.hpp

@@ -155,6 +155,10 @@ value_from_impl( no_conversion_tag, value&, T&&, Ctx const& )
 template< class Ctx, class T >
 struct from_described_member
 {
+    static_assert(
+        uniquely_named_members< remove_cvref<T> >::value,
+        "The type has several described members with the same name.");
+
     using Ds = described_members< remove_cvref<T> >;
 
     object& obj;

include/boost/json/detail/value_to.hpp

@@ -349,6 +349,10 @@ value_to_impl(
 template< class Ctx, class T >
 struct to_described_member
 {
+    static_assert(
+        uniquely_named_members<T>::value,
+        "The type has several described members with the same name.");
+
     using Ds = described_members<T>;
 
     system::result<T>& res;

include/boost/json/impl/conversion.hpp

@@ -268,10 +268,10 @@ using has_user_conversion3 = mp11::mp_if<
 
 template< class T >
 using described_non_public_members = describe::describe_members<
-    T, describe::mod_private | describe::mod_protected>;
-template< class T >
-using described_bases = describe::describe_bases<
-    T, describe::mod_any_access>;
+    T,
+    describe::mod_private
+        | describe::mod_protected
+        | boost::describe::mod_inherited>;
 
 #if defined(BOOST_MSVC) && BOOST_MSVC < 1920
 
@@ -301,6 +301,45 @@ template< class T >
 using described_members = describe::describe_members<
     T, describe::mod_any_access | describe::mod_inherited>;
 
+#ifdef BOOST_DESCRIBE_CXX14
+
+constexpr
+bool
+compare_strings(char const* l, char const* r)
+{
+#if defined(_MSC_VER) && (_MSC_VER <= 1900) && !defined(__clang__)
+    return *l == *r && ( (*l == 0) | compare_strings(l + 1, r + 1) );
+#else
+    do
+    {
+        if( *l != *r )
+            return false;
+        if( *l == 0 )
+            return true;
+        ++l;
+        ++r;
+    } while(true);
+#endif
+}
+
+template< class L, class R >
+struct equal_member_names
+    : mp11::mp_bool< compare_strings(L::name, R::name) >
+{};
+
+template< class T >
+using uniquely_named_members = mp11::mp_same<
+    mp11::mp_unique_if< described_members<T>, equal_member_names >,
+    described_members<T> >;
+
+#else
+
+// we only check this in C++14, but the template should exist nevertheless
+template< class T >
+using uniquely_named_members = std::true_type;
+
+#endif // BOOST_DESCRIBE_CXX14
+
 // user conversion (via tag_invoke)
 template< class Ctx, class T, class Dir >
 using user_conversion_category = mp11::mp_cond<
@@ -541,9 +580,7 @@ struct is_described_class
         mp11::mp_not< std::is_union<T> >,
         mp11::mp_empty<
             mp11::mp_eval_or<
-                mp11::mp_list<>, detail::described_non_public_members, T>>,
-        mp11::mp_empty<
-            mp11::mp_eval_or<mp11::mp_list<>, detail::described_bases, T>>>
+                mp11::mp_list<>, detail::described_non_public_members, T>>>
 { };
 
 template<class T>

include/boost/json/impl/serializer.hpp

@@ -463,6 +463,10 @@ write_impl(tuple_conversion_tag, writer& w, stream& ss0)
 template< class T, bool StackEmpty >
 struct serialize_struct_elem_helper
 {
+    static_assert(
+        uniquely_named_members<T>::value,
+        "The type has several described members with the same name.");
+
     writer& w;
     local_stream& ss;
     T const* pt;

test/conversion.cpp

@@ -73,44 +73,62 @@ struct pseudo_multimap1
 
 struct my_null { };
 
-struct described1 { };
-BOOST_DESCRIBE_STRUCT(described1, (), ())
+struct described1 { int n1; };
+BOOST_DESCRIBE_STRUCT(described1, (), (n1))
 
-struct described2 : described1 { };
-BOOST_DESCRIBE_STRUCT(described2, (described1), ())
+struct described2 : described1 { int n2; };
+BOOST_DESCRIBE_STRUCT(described2, (described1), (n2))
 
-struct described3
+struct described3 : private described1 { int n3; };
+BOOST_DESCRIBE_STRUCT(described3, (described1), (n3))
+
+struct described4 : protected described1 { };
+BOOST_DESCRIBE_STRUCT(described4, (described1), ())
+
+struct described5 : private described2, protected described3 { };
+BOOST_DESCRIBE_STRUCT(described5, (), ())
+
+struct described6
 {
     int n;
 
 private:
     int m;
 };
-BOOST_DESCRIBE_STRUCT(described3, (), (n))
+BOOST_DESCRIBE_STRUCT(described6, (), (n))
 
-struct described4
+struct described7
 {
     int n;
 
 private:
     int m;
-    BOOST_DESCRIBE_CLASS(described4, (), (n), (), (m))
+    BOOST_DESCRIBE_CLASS(described7, (), (n), (), (m))
 };
 
-struct described5
+struct described8
 {
     int n;
 
 protected:
     int m;
-    BOOST_DESCRIBE_CLASS(described5, (), (n), (m), ())
+    BOOST_DESCRIBE_CLASS(described8, (), (n), (m), ())
 };
 
-union described6
+union described9
 {
     int n;
 };
-BOOST_DESCRIBE_STRUCT(described6, (), (n))
+BOOST_DESCRIBE_STRUCT(described9, (), (n))
+
+struct base1 {};
+BOOST_DESCRIBE_STRUCT(base1, (), ())
+
+struct base2 : private base1 {};
+BOOST_DESCRIBE_STRUCT(base2, (base1), ())
+
+struct described10 : base2 {};
+BOOST_DESCRIBE_STRUCT(described10, (base2), ())
 
 enum class described_enum { e };
 BOOST_DESCRIBE_ENUM(described_enum, e)
@@ -182,13 +200,17 @@ class conversion_test
 
 #ifdef BOOST_DESCRIBE_CXX14
         BOOST_STATIC_ASSERT( is_described_class<described1>::value );
-        BOOST_STATIC_ASSERT( is_described_class<described3>::value );
+        BOOST_STATIC_ASSERT( is_described_class<described2>::value );
+        BOOST_STATIC_ASSERT( is_described_class<described5>::value );
+        BOOST_STATIC_ASSERT( is_described_class<described6>::value );
 
         BOOST_STATIC_ASSERT( !is_described_class<my_null>::value );
-        BOOST_STATIC_ASSERT( !is_described_class<described2>::value );
+        BOOST_STATIC_ASSERT( !is_described_class<described3>::value );
         BOOST_STATIC_ASSERT( !is_described_class<described4>::value );
-        BOOST_STATIC_ASSERT( !is_described_class<described5>::value );
-        BOOST_STATIC_ASSERT( !is_described_class<described6>::value );
+        BOOST_STATIC_ASSERT( !is_described_class<described7>::value );
+        BOOST_STATIC_ASSERT( !is_described_class<described8>::value );
+        BOOST_STATIC_ASSERT( !is_described_class<described9>::value );
+        // BOOST_STATIC_ASSERT( !is_described_class<described10>::value );
 
         BOOST_STATIC_ASSERT( is_described_enum<described_enum>::value );
         BOOST_STATIC_ASSERT( !is_described_enum<my_null>::value );

test/value_from.cpp

@@ -184,6 +184,18 @@ struct T11 : T10
 {
     std::string s;
 
+    void
+    set_n(int v)
+    {
+        n = v;
+    }
+
+    void
+    set_d(double v)
+    {
+        d = v;
+    }
+
     void
     set_b(bool v)
     {
@@ -196,6 +208,24 @@ struct T11 : T10
     BOOST_DESCRIBE_CLASS(T11, (T10), (s), (), (b))
 };
 
+struct Base1
+{
+    int a = 1;
+};
+BOOST_DESCRIBE_STRUCT(Base1, (), (a))
+
+struct Base2
+{
+    int a = 2;
+};
+BOOST_DESCRIBE_STRUCT(Base2, (), (a))
+
+struct Derived: Base1, Base2
+{
+    int a = 3;
+};
+BOOST_DESCRIBE_STRUCT(Derived, (Base1, Base2), ())
+
 //----------------------------------------------------------
 
 BOOST_DEFINE_ENUM_CLASS(E1, a, b, c)
@@ -495,10 +525,10 @@ class value_from_test
         BOOST_TEST(( jv == value{{"n", 909}, {"d", -1.45}} ));
 
         ::value_from_test_ns::T11 t11;
-        t11.n = 67;
-        t11.d = -.12;
-        t11.s = "qwerty";
+        t11.set_n(67);
+        t11.set_d(-.12);
         t11.set_b(true);
+        t11.s = "qwerty";
         jv = value_from( t11, ctx... );
         BOOST_TEST(( jv == value{{"n", 67}, {"d", -.12}, {"s", "qwerty"}, {"b", true}} ));