This is an automated email from the ASF dual-hosted git repository.
chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/fory.git
The following commit(s) were added to refs/heads/main by this push:
new 5a2252d33 fix(cpp): validate polymorphic smart pointer reads (#3887)
5a2252d33 is described below
commit 5a2252d33802d42649b7004f939de5d9c7ea5234
Author: Shawn Yang <[email protected]>
AuthorDate: Mon Jul 27 10:33:46 2026 +0800
fix(cpp): validate polymorphic smart pointer reads (#3887)
## Why?
## What does this PR do?
## Related issues
## AI Contribution Checklist
- [ ] Substantial AI assistance was used in this PR: `yes` / `no`
- [ ] If `yes`, I included a completed [AI Contribution
Checklist](https://github.com/apache/fory/blob/main/AI_POLICY.md#9-contributor-checklist-for-ai-assisted-prs)
in this PR description and the required `AI Usage Disclosure`.
- [ ] If `yes`, my PR description includes the required `ai_review`
summary and screenshot evidence or equivalent persisted links of the
final clean AI review results from both fresh reviewers described in
`AI_POLICY.md`, the Fory-guided reviewer and the independent general
reviewer, on the current PR diff or current HEAD after the latest code
changes.
## Does this PR introduce any user-facing change?
- [ ] Does this PR introduce any public API change?
- [ ] Does this PR introduce any binary protocol compatibility change?
## Benchmark
---
cpp/fory/meta/field_info.h | 11 +-
cpp/fory/serialization/collection_serializer.h | 264 ++++------
.../serialization/collection_serializer_test.cc | 18 +
cpp/fory/serialization/fory.h | 2 +-
cpp/fory/serialization/map_serializer.h | 128 ++++-
cpp/fory/serialization/map_serializer_test.cc | 67 +++
cpp/fory/serialization/ref_resolver.h | 36 +-
cpp/fory/serialization/serializer.h | 25 +
.../serialization/smart_ptr_serializer_test.cc | 583 +++++++++++++++++++++
cpp/fory/serialization/smart_ptr_serializers.h | 216 ++++++--
cpp/fory/serialization/type_info.h | 15 +-
cpp/fory/serialization/type_resolver.h | 116 ++++
cpp/fory/serialization/weak_ptr_serializer.h | 23 +-
cpp/fory/serialization/weak_ptr_serializer_test.cc | 44 ++
docs/guide/cpp/custom-serializers.md | 2 +-
docs/guide/cpp/polymorphism.md | 25 +-
16 files changed, 1320 insertions(+), 255 deletions(-)
diff --git a/cpp/fory/meta/field_info.h b/cpp/fory/meta/field_info.h
index 91b723153..bacaf47f1 100644
--- a/cpp/fory/meta/field_info.h
+++ b/cpp/fory/meta/field_info.h
@@ -649,6 +649,12 @@ constexpr auto concat_tuples_from_tuple(const Tuple
&tuple) {
::fory::meta::details::wrap_tuple(decltype(::fory::meta::fory_field_info(
\
::std::declval<FORY_BASE_TYPE(arg)>()))::entries),
+#define FORY_BASE_TYPE_ARG(arg)
\
+ FORY_PP_IF(FORY_PP_IS_BASE(arg))
\
+ (FORY_BASE_TYPE_ARG_IMPL(arg), FORY_PP_EMPTY())
+#define FORY_BASE_TYPE_ARG_IMPL(arg)
\
+ ::fory::meta::Identity<FORY_BASE_TYPE(arg)>{},
+
#define FORY_BASE_SIZE_ADD(arg)
\
FORY_PP_IF(FORY_PP_IS_BASE(arg))
\
(+decltype(::fory::meta::fory_field_info(
\
@@ -684,7 +690,7 @@ constexpr auto concat_tuples_from_tuple(const Tuple &tuple)
{
::std::tuple{FORY_PP_FOREACH(FORY_BASE_CONFIG_ARG, __VA_ARGS__)});
\
static inline constexpr auto FieldConfigEntries = ::std::tuple{
\
FORY_PP_FOREACH(FORY_FIELD_INFO_CONFIG_FUNC, __VA_ARGS__)};
\
- static constexpr bool has_config = true;
\
+ [[maybe_unused]] static constexpr bool has_config = true;
\
static inline constexpr auto entries =
\
::fory::meta::concat_tuples(BaseConfigEntries, FieldConfigEntries);
\
using FieldConfigEntriesType = ::std::decay_t<decltype(entries)>;
\
@@ -694,6 +700,8 @@ constexpr auto concat_tuples_from_tuple(const Tuple &tuple)
{
::fory::meta::concat_arrays(BaseNames, FieldNames);
\
using BasePtrsType = decltype(::fory::meta::concat_tuples_from_tuple(
\
::std::tuple{FORY_PP_FOREACH(FORY_BASE_PTRS_ARG, __VA_ARGS__)}));
\
+ using DirectBaseTypes = decltype(::std::tuple{
\
+ FORY_PP_FOREACH(FORY_BASE_TYPE_ARG, __VA_ARGS__)});
\
static constexpr BasePtrsType base_ptrs() {
\
return ::fory::meta::concat_tuples_from_tuple(
\
::std::tuple{FORY_PP_FOREACH(FORY_BASE_PTRS_ARG, __VA_ARGS__)});
\
@@ -744,6 +752,7 @@ constexpr auto concat_tuples_from_tuple(const Tuple &tuple)
{
[[maybe_unused]] static constexpr bool has_config = false;
\
[[maybe_unused]] static inline constexpr auto entries = ::std::tuple{};
\
[[maybe_unused]] static constexpr ::std::size_t field_count = 0;
\
+ using DirectBaseTypes = ::std::tuple<>;
\
using PtrsType = decltype(::std::tuple{});
\
static constexpr PtrsType ptrs() { return {}; }
\
static const PtrsType &ptrs_ref() {
\
diff --git a/cpp/fory/serialization/collection_serializer.h
b/cpp/fory/serialization/collection_serializer.h
index 91ec2899d..6074b147a 100644
--- a/cpp/fory/serialization/collection_serializer.h
+++ b/cpp/fory/serialization/collection_serializer.h
@@ -26,6 +26,7 @@
#include <cstring>
#include <deque>
#include <forward_list>
+#include <functional>
#include <limits>
#include <list>
#include <set>
@@ -207,6 +208,16 @@ inline void write_collection_data_fast(const Container
&coll, WriteContext &ctx,
}
}
+template <typename T, typename Elem>
+FORY_ALWAYS_INLINE const T &collection_value(const Elem &elem) {
+ if constexpr (std::is_same_v<std::decay_t<Elem>,
+ std::reference_wrapper<const T>>) {
+ return elem.get();
+ } else {
+ return elem;
+ }
+}
+
/// write collection data for polymorphic or shared-ref elements.
template <typename T, typename Container>
inline void write_collection_data_slow(const Container &coll, WriteContext
&ctx,
@@ -220,6 +231,8 @@ inline void write_collection_data_slow(const Container
&coll, WriteContext &ctx,
constexpr bool elem_is_polymorphic = is_polymorphic_v<T>;
constexpr bool elem_is_shared_ref = is_shared_ref_v<T>;
+ constexpr bool elem_is_smart_ptr =
+ is_std_shared_ptr_v<T> || is_std_unique_ptr_v<T>;
using ElemType = nullable_element_t<T>;
bool is_elem_declared =
@@ -231,7 +244,8 @@ inline void write_collection_data_slow(const Container
&coll, WriteContext &ctx,
std::type_index first_type{typeid(void)};
bool first_type_set = false;
- for (const auto &elem : coll) {
+ for (const auto &raw_elem : coll) {
+ const T &elem = collection_value<T>(raw_elem);
// Check for nulls
if constexpr (is_nullable_v<T>) {
if (is_null_value(elem)) {
@@ -283,6 +297,8 @@ inline void write_collection_data_slow(const Container
&coll, WriteContext &ctx,
ctx.write_uint8(bitmap);
// write element type info if IS_SAME_TYPE && !IS_DECL_ELEMENT_TYPE
+ const TypeInfo *elem_type_info = nullptr;
+ Harness::WriteDataFn elem_writer = nullptr;
if (is_same_type && !(bitmap & COLL_DECL_ELEMENT_TYPE)) {
if constexpr (elem_is_polymorphic) {
// write concrete type info for polymorphic elements
@@ -291,12 +307,16 @@ inline void write_collection_data_slow(const Container
&coll, WriteContext &ctx,
ctx.set_error(std::move(type_info_res).error());
return;
}
+ elem_type_info = type_info_res.value();
auto write_res =
- ctx.write_any_type_info(type_info_res.value()->type_id, first_type);
+ ctx.write_any_type_info(elem_type_info->type_id, first_type);
if (FORY_PREDICT_FALSE(!write_res.ok())) {
ctx.set_error(std::move(write_res).error());
return;
}
+ if constexpr (elem_is_smart_ptr) {
+ elem_writer = elem_type_info->harness.write_data_fn;
+ }
} else {
Serializer<ElemType>::write_type_info(ctx);
}
@@ -310,13 +330,24 @@ inline void write_collection_data_slow(const Container
&coll, WriteContext &ctx,
// All elements have same type - type info written once above
if (tracking_refs) {
// Track refs - write ref flag per element per xlang spec
- for (const auto &elem : coll) {
- Serializer<T>::write(elem, ctx, RefMode::Tracking, false,
has_generics);
+ for (const auto &raw_elem : coll) {
+ const T &elem = collection_value<T>(raw_elem);
+ if constexpr (elem_is_polymorphic && elem_is_smart_ptr) {
+ Serializer<T>::write_with_data(elem, ctx, RefMode::Tracking,
+ elem_writer, has_generics);
+ } else {
+ Serializer<T>::write(elem, ctx, RefMode::Tracking, false,
+ has_generics);
+ }
}
} else if (!has_null) {
// No nulls, no ref tracking - write data directly without null flag
- for (const auto &elem : coll) {
- if constexpr (is_nullable_v<T>) {
+ for (const auto &raw_elem : coll) {
+ const T &elem = collection_value<T>(raw_elem);
+ if constexpr (elem_is_polymorphic && elem_is_smart_ptr) {
+ Serializer<T>::write_with_data(elem, ctx, RefMode::None, elem_writer,
+ has_generics);
+ } else if constexpr (is_nullable_v<T>) {
using Inner = nullable_element_t<T>;
Serializer<Inner>::write_data(deref_nullable(elem), ctx);
} else if constexpr (elem_is_shared_ref) {
@@ -332,25 +363,35 @@ inline void write_collection_data_slow(const Container
&coll, WriteContext &ctx,
}
} else {
// Has null elements - write with null flag
- for (const auto &elem : coll) {
- Serializer<T>::write(elem, ctx, RefMode::NullOnly, false,
has_generics);
+ for (const auto &raw_elem : coll) {
+ const T &elem = collection_value<T>(raw_elem);
+ if constexpr (elem_is_polymorphic && elem_is_smart_ptr) {
+ Serializer<T>::write_with_data(elem, ctx, RefMode::NullOnly,
+ elem_writer, has_generics);
+ } else {
+ Serializer<T>::write(elem, ctx, RefMode::NullOnly, false,
+ has_generics);
+ }
}
}
} else {
// Heterogeneous types - write type info per element
if (tracking_refs) {
// Track refs - write ref flag + type info per element
- for (const auto &elem : coll) {
+ for (const auto &raw_elem : coll) {
+ const T &elem = collection_value<T>(raw_elem);
Serializer<T>::write(elem, ctx, RefMode::Tracking, true, has_generics);
}
} else if (!has_null) {
// No nulls - write without null flag (RefMode::None)
- for (const auto &elem : coll) {
+ for (const auto &raw_elem : coll) {
+ const T &elem = collection_value<T>(raw_elem);
Serializer<T>::write(elem, ctx, RefMode::None, true, has_generics);
}
} else {
// Has null elements - write with null flag (RefMode::NullOnly)
- for (const auto &elem : coll) {
+ for (const auto &raw_elem : coll) {
+ const T &elem = collection_value<T>(raw_elem);
Serializer<T>::write(elem, ctx, RefMode::NullOnly, true, has_generics);
}
}
@@ -461,6 +502,8 @@ inline Container read_collection_data_slow(ReadContext
&ctx, uint32_t length) {
}
constexpr bool elem_is_polymorphic = is_polymorphic_v<T>;
+ constexpr bool elem_is_smart_ptr =
+ is_std_shared_ptr_v<T> || is_std_unique_ptr_v<T>;
uint8_t bitmap = ctx.read_uint8(ctx.error());
if (FORY_PREDICT_FALSE(ctx.has_error())) {
@@ -476,13 +519,30 @@ inline Container read_collection_data_slow(ReadContext
&ctx, uint32_t length) {
bool is_decl_type = (bitmap & COLL_DECL_ELEMENT_TYPE) != 0;
bool is_same_type = (bitmap & COLL_IS_SAME_TYPE) != 0;
+ if constexpr (elem_is_polymorphic) {
+ if (FORY_PREDICT_FALSE(is_same_type && is_decl_type)) {
+ ctx.set_error(Error::invalid_data(
+ "Polymorphic collection elements require concrete type "
+ "information"));
+ return result;
+ }
+ }
+
// Read element type info if IS_SAME_TYPE && !IS_DECL_ELEMENT_TYPE
const TypeInfo *elem_type_info = nullptr;
+ Harness::ReadAsFn elem_reader = nullptr;
if (is_same_type && !is_decl_type) {
elem_type_info = ctx.read_any_type_info(ctx.error());
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return result;
}
+ if constexpr (elem_is_polymorphic && elem_is_smart_ptr) {
+ elem_reader = resolve_polymorphic_reader<nullable_element_t<T>>(
+ ctx, elem_type_info);
+ if (FORY_PREDICT_FALSE(ctx.has_error())) {
+ return result;
+ }
+ }
}
if (FORY_PREDICT_FALSE(!reserve_collection(result, ctx, length))) {
@@ -498,9 +558,15 @@ inline Container read_collection_data_slow(ReadContext
&ctx, uint32_t length) {
}
if constexpr (elem_is_polymorphic) {
// Use RefMode::Tracking to read ref flag per element
- auto elem = Serializer<T>::read_with_type_info(ctx,
RefMode::Tracking,
- *elem_type_info);
- collection_insert(result, std::move(elem));
+ if constexpr (elem_is_smart_ptr) {
+ auto elem = Serializer<T>::template read_with_type_info<true>(
+ ctx, RefMode::Tracking, *elem_type_info, elem_reader);
+ collection_insert(result, std::move(elem));
+ } else {
+ auto elem = Serializer<T>::read_with_type_info(
+ ctx, RefMode::Tracking, *elem_type_info);
+ collection_insert(result, std::move(elem));
+ }
} else {
auto elem = Serializer<T>::read(ctx, RefMode::Tracking, false);
collection_insert(result, std::move(elem));
@@ -512,9 +578,15 @@ inline Container read_collection_data_slow(ReadContext
&ctx, uint32_t length) {
return result;
}
if constexpr (elem_is_polymorphic) {
- auto elem = Serializer<T>::read_with_type_info(ctx, RefMode::None,
- *elem_type_info);
- collection_insert(result, std::move(elem));
+ if constexpr (elem_is_smart_ptr) {
+ auto elem = Serializer<T>::template read_with_type_info<true>(
+ ctx, RefMode::None, *elem_type_info, elem_reader);
+ collection_insert(result, std::move(elem));
+ } else {
+ auto elem = Serializer<T>::read_with_type_info(ctx, RefMode::None,
+ *elem_type_info);
+ collection_insert(result, std::move(elem));
+ }
} else {
auto elem = Serializer<T>::read(ctx, RefMode::None, false);
collection_insert(result, std::move(elem));
@@ -535,9 +607,15 @@ inline Container read_collection_data_slow(ReadContext
&ctx, uint32_t length) {
// For sets, skip null elements
} else {
if constexpr (elem_is_polymorphic) {
- auto elem = Serializer<T>::read_with_type_info(ctx, RefMode::None,
- *elem_type_info);
- collection_insert(result, std::move(elem));
+ if constexpr (elem_is_smart_ptr) {
+ auto elem = Serializer<T>::template read_with_type_info<true>(
+ ctx, RefMode::None, *elem_type_info, elem_reader);
+ collection_insert(result, std::move(elem));
+ } else {
+ auto elem = Serializer<T>::read_with_type_info(ctx,
RefMode::None,
+ *elem_type_info);
+ collection_insert(result, std::move(elem));
+ }
} else {
auto elem = Serializer<T>::read(ctx, RefMode::None, false);
collection_insert(result, std::move(elem));
@@ -1787,6 +1865,14 @@ struct Serializer<std::forward_list<T, Alloc>> {
temp.push_back(std::cref(elem));
}
+ // Dispatch to fast or slow path based on element type characteristics
+ constexpr bool is_fast_path = !is_polymorphic_v<T> && !is_shared_ref_v<T>;
+
+ if constexpr (!is_fast_path) {
+ write_collection_data_slow<T>(temp, ctx, has_generics);
+ return;
+ }
+
// write length
ctx.write_var_uint32(static_cast<uint32_t>(temp.size()));
@@ -1794,9 +1880,6 @@ struct Serializer<std::forward_list<T, Alloc>> {
return;
}
- // Dispatch to fast or slow path based on element type characteristics
- constexpr bool is_fast_path = !is_polymorphic_v<T> && !is_shared_ref_v<T>;
-
if constexpr (is_fast_path) {
// Check for null elements
bool has_null = false;
@@ -1874,141 +1957,6 @@ struct Serializer<std::forward_list<T, Alloc>> {
}
}
}
- } else {
- // Slow path for polymorphic or shared-ref elements
- constexpr bool elem_is_polymorphic = is_polymorphic_v<T>;
- constexpr bool elem_is_shared_ref = is_shared_ref_v<T>;
-
- using ElemType = nullable_element_t<T>;
- bool is_elem_declared =
- has_generics && !need_type_for_collection_elem<ElemType>();
-
- // Scan collection to determine header flags
- bool has_null = false;
- bool is_same_type = true;
- std::type_index first_type{typeid(void)};
- bool first_type_set = false;
-
- for (const auto &elem_ref : temp) {
- const auto &elem = elem_ref.get();
- // Check for nulls
- if constexpr (is_nullable_v<T>) {
- if (is_null_value(elem)) {
- has_null = true;
- continue;
- }
- }
- // Check runtime types for polymorphic elements
- if constexpr (elem_is_polymorphic) {
- if (is_same_type) {
- auto concrete_id = get_concrete_type_id(elem);
- if (!first_type_set) {
- first_type = concrete_id;
- first_type_set = true;
- } else if (concrete_id != first_type) {
- is_same_type = false;
- }
- }
- }
- }
-
- // If all polymorphic elements are null, treat as heterogeneous
- if constexpr (elem_is_polymorphic) {
- if (is_same_type && !first_type_set) {
- is_same_type = false;
- }
- }
-
- // Build header bitmap
- uint8_t bitmap = 0;
- if (has_null) {
- bitmap |= COLL_HAS_NULL;
- }
- if (is_elem_declared && !elem_is_polymorphic) {
- bitmap |= COLL_DECL_ELEMENT_TYPE;
- }
- if (is_same_type) {
- bitmap |= COLL_IS_SAME_TYPE;
- }
- // Only set TRACKING_REF if element is shared ref AND global ref tracking
- // is enabled
- if constexpr (elem_is_shared_ref) {
- if (ctx.track_ref()) {
- bitmap |= COLL_TRACKING_REF;
- }
- }
-
- // write header
- ctx.write_uint8(bitmap);
-
- // write element type info if IS_SAME_TYPE && !IS_DECL_ELEMENT_TYPE
- if (is_same_type && !(bitmap & COLL_DECL_ELEMENT_TYPE)) {
- if constexpr (elem_is_polymorphic) {
- auto type_info_res = ctx.type_resolver().get_type_info(first_type);
- if (FORY_PREDICT_FALSE(!type_info_res.ok())) {
- ctx.set_error(std::move(type_info_res).error());
- return;
- }
- auto write_res = ctx.write_any_type_info(
- type_info_res.value()->type_id, first_type);
- if (FORY_PREDICT_FALSE(!write_res.ok())) {
- ctx.set_error(std::move(write_res).error());
- return;
- }
- } else {
- Serializer<ElemType>::write_type_info(ctx);
- }
- }
-
- // write elements
- if (is_same_type) {
- if (!has_null) {
- if constexpr (elem_is_shared_ref) {
- for (const auto &elem_ref : temp) {
- Serializer<T>::write(elem_ref.get(), ctx, RefMode::NullOnly,
- false, has_generics);
- }
- } else {
- for (const auto &elem_ref : temp) {
- const auto &elem = elem_ref.get();
- if constexpr (is_nullable_v<T>) {
- using Inner = nullable_element_t<T>;
- Serializer<Inner>::write_data(deref_nullable(elem), ctx);
- } else {
- if constexpr (is_generic_type_v<T>) {
- Serializer<T>::write_data_generic(elem, ctx, has_generics);
- } else {
- Serializer<T>::write_data(elem, ctx);
- }
- }
- }
- }
- } else {
- for (const auto &elem_ref : temp) {
- Serializer<T>::write(elem_ref.get(), ctx, RefMode::NullOnly, false,
- has_generics);
- }
- }
- } else {
- if (!has_null) {
- if constexpr (elem_is_shared_ref) {
- for (const auto &elem_ref : temp) {
- Serializer<T>::write(elem_ref.get(), ctx, RefMode::NullOnly,
true,
- has_generics);
- }
- } else {
- for (const auto &elem_ref : temp) {
- Serializer<T>::write(elem_ref.get(), ctx, RefMode::None, true,
- has_generics);
- }
- }
- } else {
- for (const auto &elem_ref : temp) {
- Serializer<T>::write(elem_ref.get(), ctx, RefMode::NullOnly, true,
- has_generics);
- }
- }
- }
}
}
diff --git a/cpp/fory/serialization/collection_serializer_test.cc
b/cpp/fory/serialization/collection_serializer_test.cc
index c40f717e3..c6a5c6ce0 100644
--- a/cpp/fory/serialization/collection_serializer_test.cc
+++ b/cpp/fory/serialization/collection_serializer_test.cc
@@ -83,6 +83,24 @@ void register_types(Fory &fory) {
// Polymorphic Vector Tests
// ============================================================================
+TEST(CollectionSerializerTest, RejectsMissingConcreteType) {
+ Config config;
+ ReadContext ctx(config, std::make_unique<TypeResolver>());
+ Buffer buffer;
+ buffer.write_uint8(COLL_IS_SAME_TYPE | COLL_DECL_ELEMENT_TYPE);
+ ctx.attach(buffer);
+
+ using Values = std::vector<std::shared_ptr<Animal>>;
+ auto result =
+ read_collection_data_slow<std::shared_ptr<Animal>, Values>(ctx, 1);
+
+ EXPECT_TRUE(result.empty());
+ ASSERT_TRUE(ctx.has_error());
+ EXPECT_EQ(ctx.error().code(), ErrorCode::InvalidData);
+ EXPECT_NE(ctx.error().message().find("concrete type information"),
+ std::string::npos);
+}
+
TEST(CollectionSerializerTest, VectorPolymorphicHeterogeneousElements) {
auto fory = create_fory();
register_types(fory);
diff --git a/cpp/fory/serialization/fory.h b/cpp/fory/serialization/fory.h
index f9783474c..68d3df58f 100644
--- a/cpp/fory/serialization/fory.h
+++ b/cpp/fory/serialization/fory.h
@@ -868,12 +868,12 @@ private:
const RefMode top_level_ref_mode =
read_ctx_->track_ref() ? RefMode::Tracking : RefMode::NullOnly;
T result = Serializer<T>::read(*read_ctx_, top_level_ref_mode, true);
+ read_ctx_->ref_reader().resolve_callbacks(read_ctx_->error());
// Check for errors at deserialization boundary
if (FORY_PREDICT_FALSE(read_ctx_->has_error())) {
return Unexpected(read_ctx_->take_error());
}
- read_ctx_->ref_reader().resolve_callbacks();
return result;
}
diff --git a/cpp/fory/serialization/map_serializer.h
b/cpp/fory/serialization/map_serializer.h
index 0b893e829..ecfe03b94 100644
--- a/cpp/fory/serialization/map_serializer.h
+++ b/cpp/fory/serialization/map_serializer.h
@@ -250,6 +250,10 @@ inline void write_map_data_slow(const MapType &map,
WriteContext &ctx,
constexpr bool val_is_polymorphic = is_polymorphic_v<V>;
constexpr bool key_is_shared_ref = is_shared_ref_v<K>;
constexpr bool val_is_shared_ref = is_shared_ref_v<V>;
+ constexpr bool key_is_smart_ptr =
+ is_std_shared_ptr_v<K> || is_std_unique_ptr_v<K>;
+ constexpr bool val_is_smart_ptr =
+ is_std_shared_ptr_v<V> || is_std_unique_ptr_v<V>;
const bool is_key_declared =
has_generics && !need_to_write_type_for_field<K>();
@@ -264,6 +268,8 @@ inline void write_map_data_slow(const MapType &map,
WriteContext &ctx,
// Track current chunk's types for polymorphic handling
const TypeInfo *current_key_type_info = nullptr;
const TypeInfo *current_val_type_info = nullptr;
+ Harness::WriteDataFn current_key_writer = nullptr;
+ Harness::WriteDataFn current_val_writer = nullptr;
for (const auto &[key, value] : map) {
// Check if key or value is null (for nullable types: optional, shared_ptr,
@@ -304,9 +310,16 @@ inline void write_map_data_slow(const MapType &map,
WriteContext &ctx,
}
ctx.write_uint8(chunk_header);
- // write ref flag first if tracking refs
- if (write_ref) {
- write_not_null_ref_flag(ctx, RefMode::NullOnly);
+ if constexpr (key_is_shared_ref) {
+ // A null-value entry is its own chunk, but its non-null key still
+ // participates in the map's root reference graph.
+ Serializer<K>::write(key, ctx,
+ write_ref ? RefMode::Tracking : RefMode::None,
+ !(chunk_header & DECL_KEY_TYPE), has_generics);
+ if (FORY_PREDICT_FALSE(ctx.has_error())) {
+ return;
+ }
+ continue;
}
// Then write type info if not declared
@@ -357,9 +370,16 @@ inline void write_map_data_slow(const MapType &map,
WriteContext &ctx,
}
ctx.write_uint8(chunk_header);
- // write ref flag first if tracking refs
- if (write_ref) {
- write_not_null_ref_flag(ctx, RefMode::NullOnly);
+ if constexpr (val_is_shared_ref) {
+ // A null-key entry is its own chunk, but its non-null value still
+ // participates in the map's root reference graph.
+ Serializer<V>::write(value, ctx,
+ write_ref ? RefMode::Tracking : RefMode::None,
+ !(chunk_header & DECL_VALUE_TYPE),
has_generics);
+ if (FORY_PREDICT_FALSE(ctx.has_error())) {
+ return;
+ }
+ continue;
}
// Then write type info if not declared
@@ -523,13 +543,25 @@ inline void write_map_data_slow(const MapType &map,
WriteContext &ctx,
need_write_header = false;
current_key_type_info = key_type_info;
current_val_type_info = val_type_info;
+ if constexpr (key_is_polymorphic && key_is_smart_ptr) {
+ current_key_writer = key_type_info->harness.write_data_fn;
+ }
+ if constexpr (val_is_polymorphic && val_is_smart_ptr) {
+ current_val_writer = val_type_info->harness.write_data_fn;
+ }
}
// write key-value pair
// For shared_ptr with ref tracking: write ref flag + data
// For other types: null cases already handled via KEY_NULL/VALUE_NULL,
// so just write data directly
- if constexpr (key_is_shared_ref) {
+ if constexpr (key_is_polymorphic && key_is_smart_ptr) {
+ const RefMode ref_mode = key_is_shared_ref && ctx.track_ref()
+ ? RefMode::Tracking
+ : RefMode::None;
+ Serializer<K>::write_with_data(key, ctx, ref_mode, current_key_writer,
+ has_generics);
+ } else if constexpr (key_is_shared_ref) {
if (ctx.track_ref()) {
Serializer<K>::write(key, ctx, RefMode::Tracking, false, has_generics);
} else {
@@ -543,7 +575,13 @@ inline void write_map_data_slow(const MapType &map,
WriteContext &ctx,
}
}
- if constexpr (val_is_shared_ref) {
+ if constexpr (val_is_polymorphic && val_is_smart_ptr) {
+ const RefMode ref_mode = val_is_shared_ref && ctx.track_ref()
+ ? RefMode::Tracking
+ : RefMode::None;
+ Serializer<V>::write_with_data(value, ctx, ref_mode, current_val_writer,
+ has_generics);
+ } else if constexpr (val_is_shared_ref) {
if (ctx.track_ref()) {
Serializer<V>::write(value, ctx, RefMode::Tracking, false,
has_generics);
@@ -567,6 +605,8 @@ inline void write_map_data_slow(const MapType &map,
WriteContext &ctx,
need_write_header = true;
current_key_type_info = nullptr;
current_val_type_info = nullptr;
+ current_key_writer = nullptr;
+ current_val_writer = nullptr;
}
}
@@ -734,6 +774,10 @@ inline MapType read_map_data_slow(ReadContext &ctx,
uint32_t length) {
constexpr bool val_is_polymorphic = is_polymorphic_v<V>;
constexpr bool key_is_shared_ref = is_shared_ref_v<K>;
constexpr bool val_is_shared_ref = is_shared_ref_v<V>;
+ constexpr bool key_is_smart_ptr =
+ is_std_shared_ptr_v<K> || is_std_unique_ptr_v<K>;
+ constexpr bool val_is_smart_ptr =
+ is_std_shared_ptr_v<V> || is_std_unique_ptr_v<V>;
uint32_t len_counter = 0;
@@ -757,9 +801,21 @@ inline MapType read_map_data_slow(ReadContext &ctx,
uint32_t length) {
bool track_value_ref = (header & TRACKING_VALUE_REF) != 0;
bool value_declared = (header & DECL_VALUE_TYPE) != 0;
+ if constexpr (val_is_shared_ref) {
+ V value = Serializer<V>::read(
+ ctx, track_value_ref ? RefMode::Tracking : RefMode::None,
+ !value_declared);
+ if (FORY_PREDICT_FALSE(ctx.has_error())) {
+ return MapType{};
+ }
+ result.emplace(K{}, std::move(value));
+ len_counter++;
+ continue;
+ }
+
// Consume ref flag first if tracking refs
bool has_value = true;
- if (track_value_ref || val_is_shared_ref) {
+ if (track_value_ref) {
has_value = read_null_only_flag(ctx, RefMode::NullOnly);
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return MapType{};
@@ -814,9 +870,21 @@ inline MapType read_map_data_slow(ReadContext &ctx,
uint32_t length) {
bool track_key_ref = (header & TRACKING_KEY_REF) != 0;
bool key_declared = (header & DECL_KEY_TYPE) != 0;
+ if constexpr (key_is_shared_ref) {
+ K key = Serializer<K>::read(
+ ctx, track_key_ref ? RefMode::Tracking : RefMode::None,
+ !key_declared);
+ if (FORY_PREDICT_FALSE(ctx.has_error())) {
+ return MapType{};
+ }
+ result.emplace(std::move(key), V{});
+ len_counter++;
+ continue;
+ }
+
// Consume ref flag first if tracking refs
bool has_key = true;
- if (track_key_ref || key_is_shared_ref) {
+ if (track_key_ref) {
has_key = read_null_only_flag(ctx, RefMode::NullOnly);
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return MapType{};
@@ -877,6 +945,8 @@ inline MapType read_map_data_slow(ReadContext &ctx,
uint32_t length) {
// Read type info if not declared
const TypeInfo *key_type_info = nullptr;
const TypeInfo *value_type_info = nullptr;
+ Harness::ReadAsFn key_reader = nullptr;
+ Harness::ReadAsFn value_reader = nullptr;
if (!key_declared || key_is_polymorphic) {
if constexpr (key_is_polymorphic) {
@@ -884,6 +954,13 @@ inline MapType read_map_data_slow(ReadContext &ctx,
uint32_t length) {
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return MapType{};
}
+ if constexpr (key_is_smart_ptr) {
+ key_reader = resolve_polymorphic_reader<nullable_element_t<K>>(
+ ctx, key_type_info);
+ if (FORY_PREDICT_FALSE(ctx.has_error())) {
+ return MapType{};
+ }
+ }
} else {
read_type_info<K>(ctx);
}
@@ -894,6 +971,13 @@ inline MapType read_map_data_slow(ReadContext &ctx,
uint32_t length) {
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return MapType{};
}
+ if constexpr (val_is_smart_ptr) {
+ value_reader = resolve_polymorphic_reader<nullable_element_t<V>>(
+ ctx, value_type_info);
+ if (FORY_PREDICT_FALSE(ctx.has_error())) {
+ return MapType{};
+ }
+ }
} else {
read_type_info<V>(ctx);
}
@@ -919,9 +1003,15 @@ inline MapType read_map_data_slow(ReadContext &ctx,
uint32_t length) {
K key;
if constexpr (key_is_polymorphic) {
// TRACKING_KEY_REF means full ref tracking for shared_ptr
- key = Serializer<K>::read_with_type_info(
- ctx, key_read_ref ? RefMode::Tracking : RefMode::None,
- *key_type_info);
+ if constexpr (key_is_smart_ptr) {
+ key = Serializer<K>::template read_with_type_info<true>(
+ ctx, key_read_ref ? RefMode::Tracking : RefMode::None,
+ *key_type_info, key_reader);
+ } else {
+ key = Serializer<K>::read_with_type_info(
+ ctx, key_read_ref ? RefMode::Tracking : RefMode::None,
+ *key_type_info);
+ }
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return MapType{};
}
@@ -943,9 +1033,15 @@ inline MapType read_map_data_slow(ReadContext &ctx,
uint32_t length) {
V value;
if constexpr (val_is_polymorphic) {
// TRACKING_VALUE_REF means full ref tracking for shared_ptr
- value = Serializer<V>::read_with_type_info(
- ctx, val_read_ref ? RefMode::Tracking : RefMode::None,
- *value_type_info);
+ if constexpr (val_is_smart_ptr) {
+ value = Serializer<V>::template read_with_type_info<true>(
+ ctx, val_read_ref ? RefMode::Tracking : RefMode::None,
+ *value_type_info, value_reader);
+ } else {
+ value = Serializer<V>::read_with_type_info(
+ ctx, val_read_ref ? RefMode::Tracking : RefMode::None,
+ *value_type_info);
+ }
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return MapType{};
}
diff --git a/cpp/fory/serialization/map_serializer_test.cc
b/cpp/fory/serialization/map_serializer_test.cc
index dfe74e41c..0d181429c 100644
--- a/cpp/fory/serialization/map_serializer_test.cc
+++ b/cpp/fory/serialization/map_serializer_test.cc
@@ -282,6 +282,48 @@ TEST(MapSerializerTest, MapWithCircularReferences) {
EXPECT_EQ(deserialized[3].get(), deserialized[4].get());
}
+TEST(MapSerializerTest, NullChunksPreserveSharedRefs) {
+ auto fory =
+ Fory::builder().xlang(true).compatible(false).track_ref(true).build();
+
+ auto first = std::make_shared<int32_t>(11);
+ auto second = std::make_shared<int32_t>(22);
+ std::map<std::shared_ptr<int32_t>, std::shared_ptr<int32_t>> map;
+ map.emplace(first, nullptr);
+ map.emplace(second, first);
+ map.emplace(nullptr, second);
+
+ auto bytes = fory.serialize(map);
+ ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+ auto result = fory.deserialize<
+ std::map<std::shared_ptr<int32_t>, std::shared_ptr<int32_t>>>(
+ bytes->data(), bytes->size());
+ ASSERT_TRUE(result.ok()) << result.error().to_string();
+ ASSERT_EQ(result->size(), 3u);
+
+ std::shared_ptr<int32_t> null_value_key;
+ std::shared_ptr<int32_t> null_key_value;
+ std::shared_ptr<int32_t> pair_key;
+ std::shared_ptr<int32_t> pair_value;
+ for (const auto &[key, value] : *result) {
+ if (!key) {
+ null_key_value = value;
+ } else if (!value) {
+ null_value_key = key;
+ } else {
+ pair_key = key;
+ pair_value = value;
+ }
+ }
+
+ ASSERT_TRUE(null_value_key);
+ ASSERT_TRUE(null_key_value);
+ ASSERT_TRUE(pair_key);
+ ASSERT_TRUE(pair_value);
+ EXPECT_EQ(null_value_key.get(), pair_value.get());
+ EXPECT_EQ(null_key_value.get(), pair_key.get());
+}
+
// ============================================================================
// Protocol Compliance Tests
// ============================================================================
@@ -474,6 +516,31 @@ constexpr uint32_t DERIVED_KEY_B_TYPE_ID = 1001;
constexpr uint32_t DERIVED_VALUE_X_TYPE_ID = 1002;
constexpr uint32_t DERIVED_VALUE_Y_TYPE_ID = 1003;
+TEST(MapSerializerTest, RejectsUnrelatedPolymorphicValue) {
+ using namespace polymorphic_test;
+
+ for (bool compatible : {false, true}) {
+ SCOPED_TRACE(compatible);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .compatible(compatible)
+ .track_ref(true)
+ .build();
+ ASSERT_TRUE(fory.register_struct<DerivedKeyA>(DERIVED_KEY_A_TYPE_ID).ok());
+
+ std::map<int32_t, std::shared_ptr<BaseKey>> values;
+ values.emplace(1, std::make_shared<DerivedKeyA>(1, "unrelated"));
+ auto bytes = fory.serialize(values);
+ ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+
+ auto rejected =
+ fory.deserialize<std::map<int32_t, std::shared_ptr<BaseValue>>>(
+ bytes->data(), bytes->size());
+ ASSERT_FALSE(rejected.ok());
+ EXPECT_EQ(rejected.error().code(), fory::ErrorCode::TypeError);
+ }
+}
+
// Test map with polymorphic value types (most common case)
TEST(MapSerializerTest, PolymorphicValueTypes) {
using namespace polymorphic_test;
diff --git a/cpp/fory/serialization/ref_resolver.h
b/cpp/fory/serialization/ref_resolver.h
index 1a6322ad0..525fa0d44 100644
--- a/cpp/fory/serialization/ref_resolver.h
+++ b/cpp/fory/serialization/ref_resolver.h
@@ -97,7 +97,7 @@ private:
class RefReader {
public:
- using UpdateCallback = std::function<void(const RefReader &)>;
+ using UpdateCallback = std::function<void(const RefReader &, Error &)>;
RefReader() = default;
@@ -146,12 +146,15 @@ public:
template <typename T>
void add_update_callback(uint32_t ref_id, std::shared_ptr<T> *target) {
- callbacks_.emplace_back([ref_id, target](const RefReader &reader) {
- auto ref_result = reader.template get_shared_ref<T>(ref_id);
- if (ref_result.ok()) {
- *target = ref_result.value();
- }
- });
+ callbacks_.emplace_back(
+ [ref_id, target](const RefReader &reader, Error &error) {
+ auto ref_result = reader.template get_shared_ref<T>(ref_id);
+ if (FORY_PREDICT_FALSE(!ref_result.ok())) {
+ error = std::move(ref_result).error();
+ return;
+ }
+ *target = ref_result.value();
+ });
}
/// Add a callback that will be invoked when references are resolved.
@@ -167,15 +170,24 @@ public:
callbacks_.emplace_back(std::move(callback));
}
- void resolve_callbacks() {
+ void resolve_callbacks(Error &error) {
+ if (callbacks_.empty()) {
+ return;
+ }
+ if (FORY_PREDICT_FALSE(!error.ok())) {
+ callbacks_.clear();
+ return;
+ }
for (const auto &cb : callbacks_) {
- cb(*this);
+ cb(*this, error);
+ if (FORY_PREDICT_FALSE(!error.ok())) {
+ break;
+ }
}
callbacks_.clear();
}
void reset() {
- resolve_callbacks();
refs_.clear();
callbacks_.clear();
}
@@ -196,6 +208,10 @@ public:
return static_cast<uint32_t>(refs_.size() - 1);
}
+ bool is_pending_ref(uint32_t ref_id) const {
+ return ref_id < refs_.size() && !refs_[ref_id].ptr;
+ }
+
private:
struct RefSlot {
std::shared_ptr<void> ptr;
diff --git a/cpp/fory/serialization/serializer.h
b/cpp/fory/serialization/serializer.h
index 8b6a7b15a..5773cd7d8 100644
--- a/cpp/fory/serialization/serializer.h
+++ b/cpp/fory/serialization/serializer.h
@@ -170,6 +170,31 @@ inline bool type_id_matches(uint32_t actual, uint32_t
expected) {
return actual == expected;
}
+/// Resolve a declared polymorphic target before materializing the wire type.
+template <typename T>
+inline Harness::ReadAsFn resolve_polymorphic_reader(ReadContext &ctx,
+ const TypeInfo *type_info)
{
+ if (FORY_PREDICT_FALSE(type_info->harness.find_read_as_fn == nullptr)) {
+ ctx.set_error(
+ Error::type_error("No C++ type information for polymorphic read"));
+ return nullptr;
+ }
+ const std::type_info &target = typeid(T);
+ Harness::ReadAsFn read_as;
+ if (FORY_PREDICT_TRUE(type_info->cached_read_target == &target)) {
+ read_as = type_info->cached_read_as_fn;
+ } else {
+ read_as = type_info->harness.find_read_as_fn(target);
+ type_info->cached_read_as_fn = read_as;
+ type_info->cached_read_target = ⌖
+ }
+ if (FORY_PREDICT_FALSE(read_as == nullptr)) {
+ ctx.set_error(Error::type_error(
+ "Wire type is not compatible with the polymorphic target"));
+ }
+ return read_as;
+}
+
// ============================================================================
// Core Serializer API
// ============================================================================
diff --git a/cpp/fory/serialization/smart_ptr_serializer_test.cc
b/cpp/fory/serialization/smart_ptr_serializer_test.cc
index 39cc311b5..42ee624e7 100644
--- a/cpp/fory/serialization/smart_ptr_serializer_test.cc
+++ b/cpp/fory/serialization/smart_ptr_serializer_test.cc
@@ -20,6 +20,8 @@
#include "fory/serialization/fory.h"
#include "gtest/gtest.h"
#include <cstdint>
+#include <forward_list>
+#include <map>
#include <memory>
#include <optional>
#include <vector>
@@ -48,6 +50,105 @@ struct UniqueHolder {
FORY_STRUCT(UniqueHolder, value);
};
+struct NonDefaultStruct {
+ explicit NonDefaultStruct(int32_t value) : value(value) {}
+ NonDefaultStruct() = delete;
+
+ int32_t value;
+ FORY_STRUCT(NonDefaultStruct, value);
+};
+
+struct CustomPolyLeading {
+ virtual ~CustomPolyLeading() = default;
+ int32_t leading_value = 0;
+};
+
+struct CustomPolyBase {
+ virtual ~CustomPolyBase() = default;
+ int32_t base_value = 0;
+ FORY_STRUCT(CustomPolyBase, base_value);
+};
+
+struct CustomPolyDerived : CustomPolyLeading, CustomPolyBase {
+ inline static int reads = 0;
+ int32_t derived_value = 0;
+};
+
+template <> struct Serializer<CustomPolyDerived> {
+ static constexpr TypeId type_id = TypeId::EXT;
+
+ static void write(const CustomPolyDerived &value, WriteContext &ctx,
+ RefMode ref_mode, bool write_type,
+ bool has_generics = false) {
+ (void)has_generics;
+ write_not_null_ref_flag(ctx, ref_mode);
+ if (write_type) {
+ auto result =
+ ctx.write_any_type_info(static_cast<uint32_t>(type_id),
+ std::type_index(typeid(CustomPolyDerived)));
+ if (!result.ok()) {
+ ctx.set_error(std::move(result).error());
+ return;
+ }
+ }
+ write_data(value, ctx);
+ }
+
+ static void write_data(const CustomPolyDerived &value, WriteContext &ctx) {
+ Serializer<int32_t>::write_data(value.leading_value, ctx);
+ Serializer<int32_t>::write_data(value.base_value, ctx);
+ Serializer<int32_t>::write_data(value.derived_value, ctx);
+ }
+
+ static void write_data_generic(const CustomPolyDerived &value,
+ WriteContext &ctx, bool has_generics) {
+ (void)has_generics;
+ write_data(value, ctx);
+ }
+
+ static CustomPolyDerived read(ReadContext &ctx, RefMode ref_mode,
+ bool read_type) {
+ bool has_value = read_null_only_flag(ctx, ref_mode);
+ if (ctx.has_error() || !has_value) {
+ return {};
+ }
+ if (read_type) {
+ const TypeInfo *type_info = ctx.read_any_type_info(ctx.error());
+ if (ctx.has_error()) {
+ return {};
+ }
+ if (type_info == nullptr) {
+ ctx.set_error(
+ Error::type_error("TypeInfo for CustomPolyDerived not found"));
+ return {};
+ }
+ }
+ return read_data(ctx);
+ }
+
+ static CustomPolyDerived read_data(ReadContext &ctx) {
+ ++CustomPolyDerived::reads;
+ CustomPolyDerived value;
+ value.leading_value = Serializer<int32_t>::read_data(ctx);
+ value.base_value = Serializer<int32_t>::read_data(ctx);
+ value.derived_value = Serializer<int32_t>::read_data(ctx);
+ return value;
+ }
+
+ static CustomPolyDerived read_data_generic(ReadContext &ctx,
+ bool has_generics) {
+ (void)has_generics;
+ return read_data(ctx);
+ }
+
+ static CustomPolyDerived read_with_type_info(ReadContext &ctx,
+ RefMode ref_mode,
+ const TypeInfo &type_info) {
+ (void)type_info;
+ return read(ctx, ref_mode, false);
+ }
+};
+
namespace {
Fory create_serializer(bool track_ref) {
@@ -184,6 +285,16 @@ TEST(SmartPtrSerializerTest, UniquePtrNullRoundTrip) {
EXPECT_EQ(deserialized.value, nullptr);
}
+TEST(SmartPtrSerializerTest, RegistersNonDefaultStruct) {
+ auto fory = create_serializer(true);
+ ASSERT_TRUE(
+ fory.register_struct<NonDefaultStruct>("test", "NonDefaultStruct").ok());
+
+ NonDefaultStruct value(42);
+ auto bytes = fory.serialize(value);
+ ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+}
+
// ============================================================================
// Polymorphic type tests
// ============================================================================
@@ -207,6 +318,63 @@ struct Derived2 : Base {
FORY_STRUCT(Derived2, FORY_BASE(Base), derived2_data);
};
+struct Unrelated {
+ inline static int constructions = 0;
+
+ Unrelated() { ++constructions; }
+ Unrelated(const Unrelated &other) : value(other.value) { ++constructions; }
+ Unrelated(Unrelated &&other) noexcept : value(other.value) {
+ ++constructions;
+ }
+ Unrelated &operator=(const Unrelated &) = default;
+ Unrelated &operator=(Unrelated &&) = default;
+ virtual ~Unrelated() = default;
+
+ int32_t value = 0;
+ FORY_STRUCT(Unrelated, value);
+};
+
+struct LeadingBase {
+ virtual ~LeadingBase() = default;
+ int32_t leading_value = 0;
+ FORY_STRUCT(LeadingBase, leading_value);
+};
+
+struct IntermediateBase : Base {
+ FORY_STRUCT(IntermediateBase, FORY_BASE(Base));
+};
+
+struct OffsetDerived : LeadingBase, IntermediateBase {
+ std::string get_type() const override { return "OffsetDerived"; }
+ int32_t derived_value = 0;
+ FORY_STRUCT(OffsetDerived, FORY_BASE(LeadingBase),
+ FORY_BASE(IntermediateBase), derived_value);
+};
+
+struct VirtualDerived : virtual Base {
+ std::string get_type() const override { return "VirtualDerived"; }
+ int32_t derived_value = 0;
+ FORY_STRUCT(VirtualDerived, FORY_BASE(Base), derived_value);
+};
+
+struct VirtualData {
+ int32_t data_value = 0;
+ FORY_STRUCT(VirtualData, data_value);
+};
+
+struct MixedVirtualDerived : Base, virtual VirtualData {
+ std::string get_type() const override { return "MixedVirtualDerived"; }
+ int32_t derived_value = 0;
+ FORY_STRUCT(MixedVirtualDerived, FORY_BASE(Base), FORY_BASE(VirtualData),
+ derived_value);
+};
+
+struct UndeclaredDerived : LeadingBase, Base {
+ std::string get_type() const override { return "UndeclaredDerived"; }
+ int32_t derived_value = 0;
+ FORY_STRUCT(UndeclaredDerived, derived_value);
+};
+
struct PolymorphicSharedHolder {
std::shared_ptr<Base> ptr;
FORY_STRUCT(PolymorphicSharedHolder, ptr);
@@ -217,6 +385,421 @@ struct PolymorphicUniqueHolder {
FORY_STRUCT(PolymorphicUniqueHolder, ptr);
};
+void register_polymorphic_types(Fory &fory) {
+ ASSERT_TRUE(fory.register_struct<Base>("test", "Base").ok());
+ ASSERT_TRUE(fory.register_struct<Derived1>("test", "Derived1").ok());
+ ASSERT_TRUE(fory.register_struct<Unrelated>("test", "Unrelated").ok());
+ ASSERT_TRUE(
+ fory.register_struct<OffsetDerived>("test", "OffsetDerived").ok());
+ ASSERT_TRUE(
+ fory.register_struct<VirtualDerived>("test", "VirtualDerived").ok());
+ ASSERT_TRUE(
+ fory.register_struct<MixedVirtualDerived>("test", "MixedVirtualDerived")
+ .ok());
+}
+
+TEST(SmartPtrSerializerTest, RejectsUnrelatedSharedType) {
+ for (bool compatible : {false, true}) {
+ SCOPED_TRACE(compatible);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(true)
+ .compatible(compatible)
+ .build();
+ register_polymorphic_types(fory);
+
+ auto unrelated = std::make_shared<Unrelated>();
+ unrelated->value = 42;
+ auto bytes_result = fory.serialize(unrelated);
+ ASSERT_TRUE(bytes_result.ok()) << bytes_result.error().to_string();
+
+ Unrelated::constructions = 0;
+ auto rejected = fory.deserialize<std::shared_ptr<Base>>(
+ bytes_result->data(), bytes_result->size());
+ ASSERT_FALSE(rejected.ok());
+ EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+ EXPECT_NE(rejected.error().message().find("not compatible"),
+ std::string::npos);
+ EXPECT_EQ(Unrelated::constructions, 0);
+
+ std::shared_ptr<Base> valid = std::make_shared<Derived1>();
+ valid->base_value = 17;
+ auto valid_bytes = fory.serialize(valid);
+ ASSERT_TRUE(valid_bytes.ok()) << valid_bytes.error().to_string();
+ auto decoded = fory.deserialize<std::shared_ptr<Base>>(valid_bytes->data(),
+
valid_bytes->size());
+ ASSERT_TRUE(decoded.ok()) << decoded.error().to_string();
+ ASSERT_NE(decoded.value(), nullptr);
+ EXPECT_EQ(decoded.value()->get_type(), "Derived1");
+ EXPECT_EQ(decoded.value()->base_value, 17);
+ }
+}
+
+TEST(SmartPtrSerializerTest, RejectsUnrelatedUniqueType) {
+ for (bool compatible : {false, true}) {
+ SCOPED_TRACE(compatible);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(true)
+ .compatible(compatible)
+ .build();
+ register_polymorphic_types(fory);
+
+ auto unrelated = std::make_unique<Unrelated>();
+ unrelated->value = 42;
+ auto bytes_result = fory.serialize(unrelated);
+ ASSERT_TRUE(bytes_result.ok()) << bytes_result.error().to_string();
+
+ Unrelated::constructions = 0;
+ auto rejected = fory.deserialize<std::unique_ptr<Base>>(
+ bytes_result->data(), bytes_result->size());
+ ASSERT_FALSE(rejected.ok());
+ EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+ EXPECT_NE(rejected.error().message().find("not compatible"),
+ std::string::npos);
+ EXPECT_EQ(Unrelated::constructions, 0);
+ }
+}
+
+TEST(SmartPtrSerializerTest, RejectsUnrelatedCollections) {
+ for (bool compatible : {false, true}) {
+ for (bool track_ref : {false, true}) {
+ SCOPED_TRACE(::testing::Message() << "compatible=" << compatible
+ << ", track_ref=" << track_ref);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(track_ref)
+ .compatible(compatible)
+ .build();
+ register_polymorphic_types(fory);
+
+ std::vector<std::shared_ptr<Unrelated>> values{
+ std::make_shared<Unrelated>()};
+ auto bytes_result = fory.serialize(values);
+ ASSERT_TRUE(bytes_result.ok()) << bytes_result.error().to_string();
+
+ Unrelated::constructions = 0;
+ auto rejected = fory.deserialize<std::vector<std::shared_ptr<Base>>>(
+ bytes_result->data(), bytes_result->size());
+ ASSERT_FALSE(rejected.ok());
+ EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+ EXPECT_EQ(Unrelated::constructions, 0);
+ }
+
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(true)
+ .compatible(compatible)
+ .build();
+ register_polymorphic_types(fory);
+ std::vector<std::unique_ptr<Unrelated>> values;
+ values.emplace_back(std::make_unique<Unrelated>());
+ auto bytes_result = fory.serialize(values);
+ ASSERT_TRUE(bytes_result.ok()) << bytes_result.error().to_string();
+
+ Unrelated::constructions = 0;
+ auto rejected = fory.deserialize<std::vector<std::unique_ptr<Base>>>(
+ bytes_result->data(), bytes_result->size());
+ ASSERT_FALSE(rejected.ok());
+ EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+ EXPECT_EQ(Unrelated::constructions, 0);
+ }
+}
+
+TEST(SmartPtrSerializerTest, AdjustsMultipleInheritance) {
+ for (bool compatible : {false, true}) {
+ SCOPED_TRACE(compatible);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(true)
+ .compatible(compatible)
+ .build();
+ register_polymorphic_types(fory);
+
+ auto concrete = std::make_shared<OffsetDerived>();
+ concrete->leading_value = 11;
+ concrete->base_value = 22;
+ concrete->derived_value = 33;
+ std::shared_ptr<Base> shared = concrete;
+ ASSERT_NE(static_cast<const void *>(concrete.get()),
+ static_cast<const void *>(shared.get()));
+
+ auto shared_bytes = fory.serialize(shared);
+ ASSERT_TRUE(shared_bytes.ok()) << shared_bytes.error().to_string();
+ auto shared_result = fory.deserialize<std::shared_ptr<Base>>(
+ shared_bytes->data(), shared_bytes->size());
+ ASSERT_TRUE(shared_result.ok()) << shared_result.error().to_string();
+ auto *shared_derived =
+ dynamic_cast<OffsetDerived *>(shared_result.value().get());
+ ASSERT_NE(shared_derived, nullptr);
+ EXPECT_EQ(shared_derived->leading_value, 11);
+ EXPECT_EQ(shared_derived->base_value, 22);
+ EXPECT_EQ(shared_derived->derived_value, 33);
+
+ auto unique_concrete = std::make_unique<OffsetDerived>();
+ unique_concrete->leading_value = 44;
+ unique_concrete->base_value = 55;
+ unique_concrete->derived_value = 66;
+ std::unique_ptr<Base> unique = std::move(unique_concrete);
+ auto unique_bytes = fory.serialize(unique);
+ ASSERT_TRUE(unique_bytes.ok()) << unique_bytes.error().to_string();
+ auto unique_result = fory.deserialize<std::unique_ptr<Base>>(
+ unique_bytes->data(), unique_bytes->size());
+ ASSERT_TRUE(unique_result.ok()) << unique_result.error().to_string();
+ auto *unique_derived =
+ dynamic_cast<OffsetDerived *>(unique_result.value().get());
+ ASSERT_NE(unique_derived, nullptr);
+ EXPECT_EQ(unique_derived->leading_value, 44);
+ EXPECT_EQ(unique_derived->base_value, 55);
+ EXPECT_EQ(unique_derived->derived_value, 66);
+
+ std::vector<std::shared_ptr<Base>> shared_values;
+ auto shared_value = std::make_shared<OffsetDerived>();
+ shared_value->leading_value = 71;
+ shared_value->base_value = 72;
+ shared_value->derived_value = 73;
+ shared_values.push_back(std::move(shared_value));
+ auto shared_vector_bytes = fory.serialize(shared_values);
+ ASSERT_TRUE(shared_vector_bytes.ok())
+ << shared_vector_bytes.error().to_string();
+ auto shared_vector_result =
+ fory.deserialize<std::vector<std::shared_ptr<Base>>>(
+ shared_vector_bytes->data(), shared_vector_bytes->size());
+ ASSERT_TRUE(shared_vector_result.ok())
+ << shared_vector_result.error().to_string();
+ ASSERT_EQ(shared_vector_result->size(), 1u);
+ auto *shared_vector_derived =
+ dynamic_cast<OffsetDerived *>(shared_vector_result->front().get());
+ ASSERT_NE(shared_vector_derived, nullptr);
+ EXPECT_EQ(shared_vector_derived->leading_value, 71);
+ EXPECT_EQ(shared_vector_derived->base_value, 72);
+ EXPECT_EQ(shared_vector_derived->derived_value, 73);
+
+ std::vector<std::unique_ptr<Base>> unique_values;
+ auto unique_value = std::make_unique<OffsetDerived>();
+ unique_value->leading_value = 81;
+ unique_value->base_value = 82;
+ unique_value->derived_value = 83;
+ unique_values.push_back(std::move(unique_value));
+ auto unique_vector_bytes = fory.serialize(unique_values);
+ ASSERT_TRUE(unique_vector_bytes.ok())
+ << unique_vector_bytes.error().to_string();
+ auto unique_vector_result =
+ fory.deserialize<std::vector<std::unique_ptr<Base>>>(
+ unique_vector_bytes->data(), unique_vector_bytes->size());
+ ASSERT_TRUE(unique_vector_result.ok())
+ << unique_vector_result.error().to_string();
+ ASSERT_EQ(unique_vector_result->size(), 1u);
+ auto *unique_vector_derived =
+ dynamic_cast<OffsetDerived *>(unique_vector_result->front().get());
+ ASSERT_NE(unique_vector_derived, nullptr);
+ EXPECT_EQ(unique_vector_derived->leading_value, 81);
+ EXPECT_EQ(unique_vector_derived->base_value, 82);
+ EXPECT_EQ(unique_vector_derived->derived_value, 83);
+
+ std::map<int32_t, std::shared_ptr<Base>> shared_map;
+ auto map_value = std::make_shared<OffsetDerived>();
+ map_value->leading_value = 91;
+ map_value->base_value = 92;
+ map_value->derived_value = 93;
+ shared_map.emplace(1, std::move(map_value));
+ auto shared_map_bytes = fory.serialize(shared_map);
+ ASSERT_TRUE(shared_map_bytes.ok()) << shared_map_bytes.error().to_string();
+ auto shared_map_result =
+ fory.deserialize<std::map<int32_t, std::shared_ptr<Base>>>(
+ shared_map_bytes->data(), shared_map_bytes->size());
+ ASSERT_TRUE(shared_map_result.ok())
+ << shared_map_result.error().to_string();
+ ASSERT_EQ(shared_map_result->size(), 1u);
+ auto *shared_map_derived =
+ dynamic_cast<OffsetDerived
*>(shared_map_result->begin()->second.get());
+ ASSERT_NE(shared_map_derived, nullptr);
+ EXPECT_EQ(shared_map_derived->leading_value, 91);
+ EXPECT_EQ(shared_map_derived->base_value, 92);
+ EXPECT_EQ(shared_map_derived->derived_value, 93);
+ }
+}
+
+TEST(SmartPtrSerializerTest, AdjustsVirtualInheritance) {
+ for (bool compatible : {false, true}) {
+ SCOPED_TRACE(compatible);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(true)
+ .compatible(compatible)
+ .build();
+ register_polymorphic_types(fory);
+
+ std::vector<std::shared_ptr<Base>> values;
+ auto value = std::make_shared<VirtualDerived>();
+ value->base_value = 101;
+ value->derived_value = 202;
+ values.push_back(std::move(value));
+
+ auto bytes = fory.serialize(values);
+ ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+ auto result = fory.deserialize<std::vector<std::shared_ptr<Base>>>(
+ bytes->data(), bytes->size());
+ ASSERT_TRUE(result.ok()) << result.error().to_string();
+ ASSERT_EQ(result->size(), 1u);
+ auto *derived = dynamic_cast<VirtualDerived *>(result->front().get());
+ ASSERT_NE(derived, nullptr);
+ EXPECT_EQ(derived->base_value, 101);
+ EXPECT_EQ(derived->derived_value, 202);
+
+ std::vector<std::shared_ptr<Base>> mixed_values;
+ auto mixed_value = std::make_shared<MixedVirtualDerived>();
+ mixed_value->base_value = 303;
+ mixed_value->data_value = 404;
+ mixed_value->derived_value = 505;
+ mixed_values.push_back(std::move(mixed_value));
+
+ auto mixed_bytes = fory.serialize(mixed_values);
+ ASSERT_TRUE(mixed_bytes.ok()) << mixed_bytes.error().to_string();
+ auto mixed_result = fory.deserialize<std::vector<std::shared_ptr<Base>>>(
+ mixed_bytes->data(), mixed_bytes->size());
+ ASSERT_TRUE(mixed_result.ok()) << mixed_result.error().to_string();
+ ASSERT_EQ(mixed_result->size(), 1u);
+ auto *mixed_derived =
+ dynamic_cast<MixedVirtualDerived *>(mixed_result->front().get());
+ ASSERT_NE(mixed_derived, nullptr);
+ EXPECT_EQ(mixed_derived->base_value, 303);
+ EXPECT_EQ(mixed_derived->data_value, 404);
+ EXPECT_EQ(mixed_derived->derived_value, 505);
+ }
+}
+
+TEST(SmartPtrSerializerTest, UndeclaredBaseWrite) {
+ for (bool compatible : {false, true}) {
+ SCOPED_TRACE(compatible);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(true)
+ .compatible(compatible)
+ .build();
+ register_polymorphic_types(fory);
+ ASSERT_TRUE(
+ fory.register_struct<UndeclaredDerived>("test", "UndeclaredDerived")
+ .ok());
+
+ auto concrete = std::make_shared<UndeclaredDerived>();
+ concrete->derived_value = 123;
+ std::shared_ptr<Base> value = concrete;
+ ASSERT_NE(static_cast<const void *>(concrete.get()),
+ static_cast<const void *>(value.get()));
+
+ auto bytes = fory.serialize(value);
+ ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+ auto exact = fory.deserialize<std::shared_ptr<UndeclaredDerived>>(
+ bytes->data(), bytes->size());
+ ASSERT_TRUE(exact.ok()) << exact.error().to_string();
+ EXPECT_EQ(exact.value()->derived_value, 123);
+
+ auto rejected =
+ fory.deserialize<std::shared_ptr<Base>>(bytes->data(), bytes->size());
+ ASSERT_FALSE(rejected.ok());
+ EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+ }
+}
+
+TEST(SmartPtrSerializerTest, CustomPolymorphicExactRead) {
+ for (bool compatible : {false, true}) {
+ SCOPED_TRACE(compatible);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(true)
+ .compatible(compatible)
+ .build();
+ ASSERT_TRUE(fory.register_extension_type<CustomPolyDerived>(
+ "test", "CustomPolyDerived")
+ .ok());
+
+ auto concrete = std::make_shared<CustomPolyDerived>();
+ concrete->leading_value = 11;
+ concrete->base_value = 22;
+ concrete->derived_value = 33;
+ std::shared_ptr<CustomPolyBase> value = concrete;
+ ASSERT_NE(static_cast<const void *>(concrete.get()),
+ static_cast<const void *>(value.get()));
+
+ auto bytes = fory.serialize(value);
+ ASSERT_TRUE(bytes.ok()) << bytes.error().to_string();
+ CustomPolyDerived::reads = 0;
+ auto result = fory.deserialize<std::shared_ptr<CustomPolyDerived>>(
+ bytes->data(), bytes->size());
+ ASSERT_TRUE(result.ok()) << result.error().to_string();
+ EXPECT_EQ(CustomPolyDerived::reads, 1);
+ EXPECT_EQ(result.value()->leading_value, 11);
+ EXPECT_EQ(result.value()->base_value, 22);
+ EXPECT_EQ(result.value()->derived_value, 33);
+
+ CustomPolyDerived::reads = 0;
+ auto rejected = fory.deserialize<std::shared_ptr<CustomPolyBase>>(
+ bytes->data(), bytes->size());
+ ASSERT_FALSE(rejected.ok());
+ EXPECT_EQ(rejected.error().code(), ErrorCode::TypeError);
+ EXPECT_EQ(CustomPolyDerived::reads, 0);
+ }
+}
+
+TEST(SmartPtrSerializerTest, ForwardListPolymorphism) {
+ for (bool compatible : {false, true}) {
+ SCOPED_TRACE(compatible);
+ auto fory = Fory::builder()
+ .xlang(true)
+ .track_ref(true)
+ .compatible(compatible)
+ .build();
+ register_polymorphic_types(fory);
+
+ auto shared_value = std::make_shared<OffsetDerived>();
+ shared_value->leading_value = 601;
+ shared_value->base_value = 602;
+ shared_value->derived_value = 603;
+ std::forward_list<std::shared_ptr<Base>> shared_values{shared_value,
+ shared_value};
+
+ auto shared_bytes = fory.serialize(shared_values);
+ ASSERT_TRUE(shared_bytes.ok()) << shared_bytes.error().to_string();
+ auto shared_result =
+ fory.deserialize<std::forward_list<std::shared_ptr<Base>>>(
+ shared_bytes->data(), shared_bytes->size());
+ ASSERT_TRUE(shared_result.ok()) << shared_result.error().to_string();
+ auto shared_it = shared_result->begin();
+ ASSERT_NE(shared_it, shared_result->end());
+ auto *shared_derived = dynamic_cast<OffsetDerived *>(shared_it->get());
+ ASSERT_NE(shared_derived, nullptr);
+ EXPECT_EQ(shared_derived->leading_value, 601);
+ EXPECT_EQ(shared_derived->base_value, 602);
+ EXPECT_EQ(shared_derived->derived_value, 603);
+ auto first_ptr = shared_it->get();
+ ++shared_it;
+ ASSERT_NE(shared_it, shared_result->end());
+ EXPECT_EQ(first_ptr, shared_it->get());
+
+ std::forward_list<std::unique_ptr<Base>> unique_values;
+ auto unique_value = std::make_unique<OffsetDerived>();
+ unique_value->leading_value = 701;
+ unique_value->base_value = 702;
+ unique_value->derived_value = 703;
+ unique_values.push_front(std::move(unique_value));
+
+ auto unique_bytes = fory.serialize(unique_values);
+ ASSERT_TRUE(unique_bytes.ok()) << unique_bytes.error().to_string();
+ auto unique_result =
+ fory.deserialize<std::forward_list<std::unique_ptr<Base>>>(
+ unique_bytes->data(), unique_bytes->size());
+ ASSERT_TRUE(unique_result.ok()) << unique_result.error().to_string();
+ ASSERT_NE(unique_result->begin(), unique_result->end());
+ auto *unique_derived =
+ dynamic_cast<OffsetDerived *>(unique_result->front().get());
+ ASSERT_NE(unique_derived, nullptr);
+ EXPECT_EQ(unique_derived->leading_value, 701);
+ EXPECT_EQ(unique_derived->base_value, 702);
+ EXPECT_EQ(unique_derived->derived_value, 703);
+ }
+}
+
TEST(SmartPtrSerializerTest, PolymorphicSharedPtrDerived1) {
auto fory = create_serializer(true);
fory.register_struct<PolymorphicSharedHolder>(200);
diff --git a/cpp/fory/serialization/smart_ptr_serializers.h
b/cpp/fory/serialization/smart_ptr_serializers.h
index ea9623015..bb5b91e36 100644
--- a/cpp/fory/serialization/smart_ptr_serializers.h
+++ b/cpp/fory/serialization/smart_ptr_serializers.h
@@ -20,6 +20,7 @@
#pragma once
#include "fory/serialization/serializer.h"
+#include <cassert>
#include <memory>
#include <optional>
#include <string>
@@ -28,36 +29,54 @@ namespace fory {
namespace serialization {
// ============================================================================
-// Helper for polymorphic deserialization
+// Helpers for polymorphic smart pointers
// ============================================================================
-/// Reads polymorphic data using the appropriate harness function based on
mode.
-/// In compatible mode, uses read_compatible_fn if available to handle schema
-/// evolution. Otherwise, uses read_data_fn for direct deserialization.
-/// Returns nullptr and sets ctx.error() on failure.
-inline void *read_polymorphic_harness_data(ReadContext &ctx,
- const TypeInfo *type_info) {
- if (ctx.is_compatible()) {
- if (!type_info->harness.read_compatible_fn) {
- ctx.set_error(Error::type_error(
- "No harness read_compatible function for polymorphic type "
- "deserialization in compatible mode"));
- return nullptr;
- }
- return type_info->harness.read_compatible_fn(ctx, type_info);
- }
- if (!type_info->harness.read_data_fn) {
- ctx.set_error(Error::type_error(
- "No harness read function for polymorphic type deserialization"));
+template <typename T>
+inline void write_polymorphic_harness_data(const T &value, WriteContext &ctx,
+ bool has_generics,
+ Harness::WriteDataFn writer) {
+ assert(writer != nullptr);
+ // A smart pointer may address an offset base subobject, while the dynamic
+ // TypeInfo owns a concrete writer. Recover the complete object before that
+ // writer casts the erased address back to its concrete type.
+ writer(dynamic_cast<const void *>(std::addressof(value)), ctx, has_generics);
+}
+
+FORY_ALWAYS_INLINE void
+write_polymorphic_harness_data(const void *complete_value, WriteContext &ctx,
+ const TypeInfo &type_info, bool has_generics) {
+ // Root callers capture this address beside typeid before resolver calls so
+ // optimized builds can share the object's RTTI lookup.
+ type_info.harness.write_data_fn(complete_value, ctx, has_generics);
+}
+
+/// Reads polymorphic data through a target-validated harness function.
+/// The reader must be resolved before it runs because the wire can select any
+/// registered type and harness reads may materialize application objects.
+template <typename T>
+inline T *read_polymorphic_harness_data(ReadContext &ctx,
+ const TypeInfo *type_info,
+ Harness::ReadAsFn read_as) {
+ assert(read_as != nullptr);
+ return static_cast<T *>(read_as(ctx, type_info));
+}
+
+template <typename T>
+inline T *read_polymorphic_harness_data(ReadContext &ctx,
+ const TypeInfo *type_info) {
+ Harness::ReadAsFn read_as = resolve_polymorphic_reader<T>(ctx, type_info);
+ if (FORY_PREDICT_FALSE(ctx.has_error())) {
return nullptr;
}
- return type_info->harness.read_data_fn(ctx);
+ return read_polymorphic_harness_data<T>(ctx, type_info, read_as);
}
/// Overload for TypeInfo reference.
-inline void *read_polymorphic_harness_data(ReadContext &ctx,
- const TypeInfo &type_info) {
- return read_polymorphic_harness_data(ctx, &type_info);
+template <typename T>
+inline T *read_polymorphic_harness_data(ReadContext &ctx,
+ const TypeInfo &type_info) {
+ return read_polymorphic_harness_data<T>(ctx, &type_info);
}
// ============================================================================
@@ -263,6 +282,9 @@ template <typename T> struct Serializer<std::shared_ptr<T>>
{
"shared_ptr of nullable types "
"(optional/shared_ptr/unique_ptr/weak_ptr) is not supported. "
"Use the wrapper type directly instead.");
+ static_assert(!std::is_polymorphic_v<T> || std::has_virtual_destructor_v<T>,
+ "polymorphic shared_ptr element types require a virtual "
+ "destructor");
static constexpr TypeId type_id =
SharedPtrTypeIdHelper<T, std::is_polymorphic_v<T>>::value;
@@ -300,6 +322,7 @@ template <typename T> struct Serializer<std::shared_ptr<T>>
{
}
// For polymorphic types, serialize the concrete type dynamically
if constexpr (is_polymorphic) {
+ const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
std::type_index concrete_type_id = std::type_index(typeid(*ptr));
auto type_info_res =
ctx.type_resolver().get_type_info(concrete_type_id);
@@ -316,8 +339,8 @@ template <typename T> struct Serializer<std::shared_ptr<T>>
{
return;
}
}
- const void *value_ptr = ptr.get();
- type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+ write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+ has_generics);
} else {
// T is guaranteed to be a value type by static_assert.
Serializer<T>::write(*ptr, ctx, RefMode::None, write_type);
@@ -341,6 +364,7 @@ template <typename T> struct Serializer<std::shared_ptr<T>>
{
// For polymorphic types, serialize the concrete type dynamically
if constexpr (is_polymorphic) {
+ const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
// get the concrete type_index from the actual object
std::type_index concrete_type_id = std::type_index(typeid(*ptr));
@@ -362,10 +386,9 @@ template <typename T> struct
Serializer<std::shared_ptr<T>> {
}
}
- // Call the harness with the raw pointer (which points to DerivedType)
- // The harness will static_cast it back to the concrete type
- const void *value_ptr = ptr.get();
- type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+ // The harness expects the complete concrete object address.
+ write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+ has_generics);
} else {
// T is guaranteed to be a value type by static_assert.
Serializer<T>::write(*ptr, ctx, RefMode::None, write_type);
@@ -382,6 +405,7 @@ template <typename T> struct Serializer<std::shared_ptr<T>>
{
// For polymorphic types, use harness to serialize the concrete type
if constexpr (std::is_polymorphic_v<T>) {
+ const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
std::type_index concrete_type_id = std::type_index(typeid(*ptr));
auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
if (!type_info_res.ok()) {
@@ -389,13 +413,39 @@ template <typename T> struct
Serializer<std::shared_ptr<T>> {
return;
}
const TypeInfo *type_info = type_info_res.value();
- const void *value_ptr = ptr.get();
- type_info->harness.write_data_fn(value_ptr, ctx, false);
+ write_polymorphic_harness_data(concrete_ptr, ctx, *type_info, false);
} else {
Serializer<T>::write_data(*ptr, ctx);
}
}
+ static inline void write_with_data(const std::shared_ptr<T> &ptr,
+ WriteContext &ctx, RefMode ref_mode,
+ Harness::WriteDataFn writer,
+ bool has_generics = false) {
+ static_assert(std::is_polymorphic_v<T>);
+ if (ref_mode == RefMode::None) {
+ if (FORY_PREDICT_FALSE(!ptr)) {
+ ctx.set_error(Error::invalid("std::shared_ptr requires ref_mode != "
+ "RefMode::None to encode null state"));
+ return;
+ }
+ } else {
+ if (!ptr) {
+ ctx.write_int8(NULL_FLAG);
+ return;
+ }
+ if (ctx.track_ref()) {
+ if (ctx.ref_writer().try_write_shared_ref(ctx, ptr)) {
+ return;
+ }
+ } else {
+ ctx.write_int8(NOT_NULL_VALUE_FLAG);
+ }
+ }
+ write_polymorphic_harness_data(*ptr, ctx, has_generics, writer);
+ }
+
static inline void write_data_generic(const std::shared_ptr<T> &ptr,
WriteContext &ctx, bool has_generics) {
if (!ptr) {
@@ -406,6 +456,7 @@ template <typename T> struct Serializer<std::shared_ptr<T>>
{
// For polymorphic types, use harness to serialize the concrete type
if constexpr (std::is_polymorphic_v<T>) {
+ const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
std::type_index concrete_type_id = std::type_index(typeid(*ptr));
auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
if (!type_info_res.ok()) {
@@ -413,8 +464,8 @@ template <typename T> struct Serializer<std::shared_ptr<T>>
{
return;
}
const TypeInfo *type_info = type_info_res.value();
- const void *value_ptr = ptr.get();
- type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+ write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+ has_generics);
} else {
Serializer<T>::write_data_generic(*ptr, ctx, has_generics);
}
@@ -530,11 +581,10 @@ template <typename T> struct
Serializer<std::shared_ptr<T>> {
}
// Use the harness to deserialize the concrete type
- void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+ T *obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return nullptr;
}
- T *obj_ptr = static_cast<T *>(raw_ptr);
auto result = std::shared_ptr<T>(obj_ptr);
if (is_first_occurrence) {
ctx.ref_reader().store_shared_ref_at(reserved_ref_id, result);
@@ -610,20 +660,30 @@ template <typename T> struct
Serializer<std::shared_ptr<T>> {
}
}
+ template <bool HasReader = false>
static inline std::shared_ptr<T>
read_with_type_info(ReadContext &ctx, RefMode ref_mode,
- const TypeInfo &type_info) {
+ const TypeInfo &type_info,
+ Harness::ReadAsFn checked_reader = nullptr) {
constexpr bool is_polymorphic = std::is_polymorphic_v<T>;
+ if constexpr (HasReader) {
+ assert(checked_reader != nullptr);
+ }
// Handle ref_mode == RefMode::None case (similar to Rust)
if (ref_mode == RefMode::None) {
// For polymorphic types, use the harness to deserialize the concrete
type
if constexpr (is_polymorphic) {
- void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+ T *obj_ptr;
+ if constexpr (HasReader) {
+ obj_ptr =
+ read_polymorphic_harness_data<T>(ctx, &type_info,
checked_reader);
+ } else {
+ obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
+ }
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return nullptr;
}
- T *obj_ptr = static_cast<T *>(raw_ptr);
return std::shared_ptr<T>(obj_ptr);
} else {
// T is guaranteed to be a value type by static_assert.
@@ -694,11 +754,16 @@ template <typename T> struct
Serializer<std::shared_ptr<T>> {
DynDepthGuard dyn_depth_guard(ctx);
// Use the harness to deserialize the concrete type
- void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+ T *obj_ptr;
+ if constexpr (HasReader) {
+ obj_ptr =
+ read_polymorphic_harness_data<T>(ctx, &type_info, checked_reader);
+ } else {
+ obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
+ }
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return nullptr;
}
- T *obj_ptr = static_cast<T *>(raw_ptr);
auto result = std::shared_ptr<T>(obj_ptr);
if (flag == REF_VALUE_FLAG) {
ctx.ref_reader().store_shared_ref_at(reserved_ref_id, result);
@@ -777,6 +842,9 @@ template <typename T> struct Serializer<std::unique_ptr<T>>
{
"unique_ptr of nullable types "
"(optional/shared_ptr/unique_ptr/weak_ptr) is not supported. "
"Use the wrapper type directly instead.");
+ static_assert(!std::is_polymorphic_v<T> || std::has_virtual_destructor_v<T>,
+ "polymorphic unique_ptr element types require a virtual "
+ "destructor");
static constexpr TypeId type_id =
UniquePtrTypeIdHelper<T, std::is_polymorphic_v<T>>::value;
@@ -795,6 +863,7 @@ template <typename T> struct Serializer<std::unique_ptr<T>>
{
}
// For polymorphic types, serialize the concrete type dynamically
if constexpr (is_polymorphic) {
+ const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
std::type_index concrete_type_id = std::type_index(typeid(*ptr));
auto type_info_res =
ctx.type_resolver().get_type_info(concrete_type_id);
@@ -811,8 +880,8 @@ template <typename T> struct Serializer<std::unique_ptr<T>>
{
return;
}
}
- const void *value_ptr = ptr.get();
- type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+ write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+ has_generics);
} else {
// T is guaranteed to be a value type by static_assert.
Serializer<T>::write(*ptr, ctx, RefMode::None, write_type);
@@ -830,6 +899,7 @@ template <typename T> struct Serializer<std::unique_ptr<T>>
{
// For polymorphic types, serialize the concrete type dynamically
if constexpr (is_polymorphic) {
+ const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
std::type_index concrete_type_id = std::type_index(typeid(*ptr));
auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
if (!type_info_res.ok()) {
@@ -845,8 +915,8 @@ template <typename T> struct Serializer<std::unique_ptr<T>>
{
return;
}
}
- const void *value_ptr = ptr.get();
- type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+ write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+ has_generics);
} else {
// T is guaranteed to be a value type by static_assert.
Serializer<T>::write(*ptr, ctx, RefMode::None, write_type);
@@ -862,6 +932,7 @@ template <typename T> struct Serializer<std::unique_ptr<T>>
{
}
// For polymorphic types, use harness to serialize the concrete type
if constexpr (std::is_polymorphic_v<T>) {
+ const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
std::type_index concrete_type_id = std::type_index(typeid(*ptr));
auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
if (!type_info_res.ok()) {
@@ -869,13 +940,33 @@ template <typename T> struct
Serializer<std::unique_ptr<T>> {
return;
}
const TypeInfo *type_info = type_info_res.value();
- const void *value_ptr = ptr.get();
- type_info->harness.write_data_fn(value_ptr, ctx, false);
+ write_polymorphic_harness_data(concrete_ptr, ctx, *type_info, false);
} else {
Serializer<T>::write_data(*ptr, ctx);
}
}
+ static inline void write_with_data(const std::unique_ptr<T> &ptr,
+ WriteContext &ctx, RefMode ref_mode,
+ Harness::WriteDataFn writer,
+ bool has_generics = false) {
+ static_assert(std::is_polymorphic_v<T>);
+ if (ref_mode == RefMode::None) {
+ if (FORY_PREDICT_FALSE(!ptr)) {
+ ctx.set_error(Error::invalid("std::unique_ptr requires ref_mode != "
+ "RefMode::None to encode null state"));
+ return;
+ }
+ } else {
+ if (!ptr) {
+ ctx.write_int8(NULL_FLAG);
+ return;
+ }
+ ctx.write_int8(NOT_NULL_VALUE_FLAG);
+ }
+ write_polymorphic_harness_data(*ptr, ctx, has_generics, writer);
+ }
+
static inline void write_data_generic(const std::unique_ptr<T> &ptr,
WriteContext &ctx, bool has_generics) {
if (!ptr) {
@@ -885,6 +976,7 @@ template <typename T> struct Serializer<std::unique_ptr<T>>
{
}
// For polymorphic types, use harness to serialize the concrete type
if constexpr (std::is_polymorphic_v<T>) {
+ const void *concrete_ptr = dynamic_cast<const void *>(ptr.get());
std::type_index concrete_type_id = std::type_index(typeid(*ptr));
auto type_info_res = ctx.type_resolver().get_type_info(concrete_type_id);
if (!type_info_res.ok()) {
@@ -892,8 +984,8 @@ template <typename T> struct Serializer<std::unique_ptr<T>>
{
return;
}
const TypeInfo *type_info = type_info_res.value();
- const void *value_ptr = ptr.get();
- type_info->harness.write_data_fn(value_ptr, ctx, has_generics);
+ write_polymorphic_harness_data(concrete_ptr, ctx, *type_info,
+ has_generics);
} else {
Serializer<T>::write_data_generic(*ptr, ctx, has_generics);
}
@@ -979,11 +1071,10 @@ template <typename T> struct
Serializer<std::unique_ptr<T>> {
}
// Use the harness to deserialize the concrete type
- void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+ T *obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return nullptr;
}
- T *obj_ptr = static_cast<T *>(raw_ptr);
return std::unique_ptr<T>(obj_ptr);
} else {
// Monomorphic path: read_type=false means field is marked monomorphic
@@ -1017,20 +1108,30 @@ template <typename T> struct
Serializer<std::unique_ptr<T>> {
}
}
+ template <bool HasReader = false>
static inline std::unique_ptr<T>
read_with_type_info(ReadContext &ctx, RefMode ref_mode,
- const TypeInfo &type_info) {
+ const TypeInfo &type_info,
+ Harness::ReadAsFn checked_reader = nullptr) {
constexpr bool is_polymorphic = std::is_polymorphic_v<T>;
+ if constexpr (HasReader) {
+ assert(checked_reader != nullptr);
+ }
// Handle ref_mode == RefMode::None case (similar to Rust)
if (ref_mode == RefMode::None) {
// For polymorphic types, use the harness to deserialize the concrete
type
if constexpr (is_polymorphic) {
- void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+ T *obj_ptr;
+ if constexpr (HasReader) {
+ obj_ptr =
+ read_polymorphic_harness_data<T>(ctx, &type_info,
checked_reader);
+ } else {
+ obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
+ }
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return nullptr;
}
- T *obj_ptr = static_cast<T *>(raw_ptr);
return std::unique_ptr<T>(obj_ptr);
} else {
// T is guaranteed to be a value type by static_assert.
@@ -1072,11 +1173,16 @@ template <typename T> struct
Serializer<std::unique_ptr<T>> {
DynDepthGuard dyn_depth_guard(ctx);
// Use the harness to deserialize the concrete type
- void *raw_ptr = read_polymorphic_harness_data(ctx, type_info);
+ T *obj_ptr;
+ if constexpr (HasReader) {
+ obj_ptr =
+ read_polymorphic_harness_data<T>(ctx, &type_info, checked_reader);
+ } else {
+ obj_ptr = read_polymorphic_harness_data<T>(ctx, type_info);
+ }
if (FORY_PREDICT_FALSE(ctx.has_error())) {
return nullptr;
}
- T *obj_ptr = static_cast<T *>(raw_ptr);
return std::unique_ptr<T>(obj_ptr);
} else {
// T is guaranteed to be a value type by static_assert.
diff --git a/cpp/fory/serialization/type_info.h
b/cpp/fory/serialization/type_info.h
index d2ee3d4bc..c2c821d66 100644
--- a/cpp/fory/serialization/type_info.h
+++ b/cpp/fory/serialization/type_info.h
@@ -29,6 +29,7 @@
#include <cstdint>
#include <memory>
#include <string>
+#include <typeinfo>
#include <vector>
namespace fory {
@@ -71,6 +72,9 @@ struct Harness {
Result<std::vector<FieldInfo>, Error> (*)(TypeResolver &);
using AnyWriteFn = void (*)(const std::any &value, WriteContext &ctx);
using AnyReadFn = std::any (*)(ReadContext &ctx);
+ using ReadAsFn = void *(*)(ReadContext &ctx,
+ const struct TypeInfo *type_info);
+ using FindReadAsFn = ReadAsFn (*)(const std::type_info &target);
Harness() = default;
Harness(WriteFn write, ReadFn read, WriteDataFn write_data,
@@ -85,7 +89,8 @@ struct Harness {
bool valid() const {
return write_fn != nullptr && read_fn != nullptr &&
write_data_fn != nullptr && read_data_fn != nullptr &&
- destroy_fn != nullptr && sorted_field_infos_fn != nullptr;
+ destroy_fn != nullptr && sorted_field_infos_fn != nullptr &&
+ find_read_as_fn != nullptr;
}
WriteFn write_fn = nullptr;
@@ -97,6 +102,9 @@ struct Harness {
ReadCompatibleFn read_compatible_fn = nullptr;
AnyWriteFn any_write_fn = nullptr;
AnyReadFn any_read_fn = nullptr;
+ // Polymorphic smart-pointer reads resolve this before materializing the wire
+ // type so only declared C++ base relationships can reach an owning reader.
+ FindReadAsFn find_read_as_fn = nullptr;
};
// ============================================================================
@@ -132,6 +140,11 @@ struct TypeInfo {
fory::flat_hash_map<std::string, size_t> name_to_index;
std::vector<uint8_t> type_def;
Harness harness;
+ // TypeInfo and its harness are immutable after registration. Cache the last
+ // read target so repeated root operations avoid walking the declared base
+ // graph; ThreadSafeFory uses distinct cloned TypeInfo owners per pooled
Fory.
+ mutable const std::type_info *cached_read_target = nullptr;
+ mutable Harness::ReadAsFn cached_read_as_fn = nullptr;
// Pre-encoded meta strings for efficient writing (avoids re-encoding on each
// write)
std::unique_ptr<CachedMetaString> encoded_namespace;
diff --git a/cpp/fory/serialization/type_resolver.h
b/cpp/fory/serialization/type_resolver.h
index d73b62a2f..44d1e2822 100644
--- a/cpp/fory/serialization/type_resolver.h
+++ b/cpp/fory/serialization/type_resolver.h
@@ -1477,6 +1477,27 @@ private:
static void *harness_read_compatible_adapter_abstract(ReadContext &ctx,
const TypeInfo *ti);
+ template <typename Source, typename Target>
+ static void *harness_struct_read_as(ReadContext &ctx,
+ const TypeInfo *type_info);
+
+ template <typename Source, typename Target>
+ static void *harness_exact_read_as(ReadContext &ctx,
+ const TypeInfo *type_info);
+
+ template <typename Source, typename Current, bool MatchAddress>
+ static Harness::ReadAsFn find_struct_read_impl(const std::type_info &target);
+
+ template <typename Source, typename Bases, bool MatchAddress,
+ size_t Index = 0>
+ static Harness::ReadAsFn find_base_read_impl(const std::type_info &target);
+
+ template <typename Source, typename Current>
+ static Harness::ReadAsFn find_struct_read(const std::type_info &target);
+
+ template <typename T>
+ static Harness::ReadAsFn find_exact_read(const std::type_info &target);
+
static std::string make_name_key(const std::string &ns,
const std::string &name);
static uint64_t make_user_type_key(uint32_t type_id, uint32_t user_type_id);
@@ -1547,6 +1568,98 @@ inline void TypeResolver::check_registration_thread() {
<< "TypeResolver has been finalized, cannot register more types";
}
+template <typename Source, typename Target>
+inline void *TypeResolver::harness_struct_read_as(ReadContext &ctx,
+ const TypeInfo *type_info) {
+ static_assert(std::is_convertible_v<Source *, Target *>,
+ "polymorphic read target must be an accessible base");
+ if constexpr (std::is_abstract_v<Source> ||
+ !std::is_default_constructible_v<Source>) {
+ ctx.set_error(Error::type_error(
+ "Cannot deserialize abstract or non-default-constructible type"));
+ return nullptr;
+ } else {
+ void *value = ctx.is_compatible()
+ ? harness_read_compatible_adapter<Source>(ctx, type_info)
+ : harness_read_data_adapter<Source>(ctx);
+ return static_cast<Target *>(static_cast<Source *>(value));
+ }
+}
+
+template <typename Source, typename Target>
+inline void *TypeResolver::harness_exact_read_as(ReadContext &ctx,
+ const TypeInfo *type_info) {
+ static_assert(std::is_convertible_v<Source *, Target *>,
+ "polymorphic read target must be an accessible base");
+ // Custom serializers own their wire compatibility and have no generated
+ // compatible reader. Their exact reader must use the same data entry point
+ // in both modes.
+ if (FORY_PREDICT_FALSE(type_info->harness.read_data_fn == nullptr)) {
+ ctx.set_error(Error::type_error(
+ "No harness read function for polymorphic type deserialization"));
+ return nullptr;
+ }
+ void *value = type_info->harness.read_data_fn(ctx);
+ return static_cast<Target *>(static_cast<Source *>(value));
+}
+
+template <typename Source, typename Bases, bool MatchAddress, size_t Index>
+inline Harness::ReadAsFn
+TypeResolver::find_base_read_impl(const std::type_info &target) {
+ if constexpr (Index == std::tuple_size_v<Bases>) {
+ return nullptr;
+ } else {
+ using BaseToken = std::tuple_element_t<Index, Bases>;
+ using Base = typename BaseToken::Type;
+ Harness::ReadAsFn read_as =
+ find_struct_read_impl<Source, Base, MatchAddress>(target);
+ if (read_as != nullptr) {
+ return read_as;
+ }
+ return find_base_read_impl<Source, Bases, MatchAddress, Index + 1>(target);
+ }
+}
+
+template <typename Source, typename Current, bool MatchAddress>
+inline Harness::ReadAsFn
+TypeResolver::find_struct_read_impl(const std::type_info &target) {
+ const std::type_info ¤t = typeid(Current);
+ const bool matches = MatchAddress ? &target == ¤t : target == current;
+ if (matches) {
+ if constexpr (std::is_convertible_v<Source *, Current *>) {
+ return &harness_struct_read_as<Source, Current>;
+ }
+ return nullptr;
+ }
+ using MetaDesc = decltype(meta::fory_field_info(std::declval<Current>()));
+ return find_base_read_impl<Source, typename MetaDesc::DirectBaseTypes,
+ MatchAddress>(target);
+}
+
+template <typename Source, typename Current>
+inline Harness::ReadAsFn
+TypeResolver::find_struct_read(const std::type_info &target) {
+ // RTTI objects normally share an address. Search every declared base by
+ // address first so the hot path never calls type_info::operator==; repeat
+ // with portable equality only for types whose RTTI crosses DSO boundaries.
+ Harness::ReadAsFn read_as =
+ find_struct_read_impl<Source, Current, true>(target);
+ if (FORY_PREDICT_TRUE(read_as != nullptr)) {
+ return read_as;
+ }
+ return find_struct_read_impl<Source, Current, false>(target);
+}
+
+template <typename T>
+inline Harness::ReadAsFn
+TypeResolver::find_exact_read(const std::type_info &target) {
+ const std::type_info ¤t = typeid(T);
+ if (&target == ¤t || target == current) {
+ return &harness_exact_read_as<T, T>;
+ }
+ return nullptr;
+}
+
namespace detail {
template <typename T>
@@ -2085,6 +2198,7 @@ Harness
TypeResolver::make_struct_harness_impl(std::true_type) {
&TypeResolver::harness_read_compatible_adapter_abstract<T>);
harness.any_write_fn = &detail::any_write_adapter<T>;
harness.any_read_fn = &detail::any_read_adapter_abstract<T>;
+ harness.find_read_as_fn = &TypeResolver::find_struct_read<T, T>;
return harness;
}
@@ -2099,6 +2213,7 @@ Harness
TypeResolver::make_struct_harness_impl(std::false_type) {
&TypeResolver::harness_read_compatible_adapter<T>);
harness.any_write_fn = &detail::any_write_adapter<T>;
harness.any_read_fn = &detail::any_read_adapter<T>;
+ harness.find_read_as_fn = &TypeResolver::find_struct_read<T, T>;
return harness;
}
@@ -2111,6 +2226,7 @@ template <typename T> Harness
TypeResolver::make_serializer_harness() {
&TypeResolver::harness_empty_sorted_fields<T>);
harness.any_write_fn = &detail::any_write_adapter<T>;
harness.any_read_fn = &detail::any_read_adapter<T>;
+ harness.find_read_as_fn = &TypeResolver::find_exact_read<T>;
return harness;
}
diff --git a/cpp/fory/serialization/weak_ptr_serializer.h
b/cpp/fory/serialization/weak_ptr_serializer.h
index 3283bc5b7..31e3f836d 100644
--- a/cpp/fory/serialization/weak_ptr_serializer.h
+++ b/cpp/fory/serialization/weak_ptr_serializer.h
@@ -350,7 +350,12 @@ template <typename T> struct Serializer<SharedWeak<T>> {
return SharedWeak<T>::from(ref_result.value());
}
- // Forward reference - create empty weak and register callback
+ if (FORY_PREDICT_FALSE(!ctx.ref_reader().is_pending_ref(ref_id))) {
+ ctx.set_error(std::move(ref_result).error());
+ return SharedWeak<T>();
+ }
+
+ // Forward reference - create empty weak and register callback.
SharedWeak<T> result;
add_weak_update_callback(ctx.ref_reader(), ref_id, result);
return result;
@@ -415,7 +420,12 @@ template <typename T> struct Serializer<SharedWeak<T>> {
return SharedWeak<T>::from(ref_result.value());
}
- // Forward reference
+ if (FORY_PREDICT_FALSE(!ctx.ref_reader().is_pending_ref(ref_id))) {
+ ctx.set_error(std::move(ref_result).error());
+ return SharedWeak<T>();
+ }
+
+ // Forward reference.
SharedWeak<T> result;
add_weak_update_callback(ctx.ref_reader(), ref_id, result);
return result;
@@ -448,11 +458,14 @@ private:
// Capture a copy of the SharedWeak - it shares internal storage
SharedWeak<T> weak_copy = weak;
ref_reader.add_update_callback(
- ref_id, [weak_copy, ref_id](const RefReader &reader) mutable {
+ ref_id,
+ [weak_copy, ref_id](const RefReader &reader, Error &error) mutable {
auto ref_result = reader.template get_shared_ref<T>(ref_id);
- if (ref_result.ok()) {
- weak_copy.update(std::weak_ptr<T>(ref_result.value()));
+ if (FORY_PREDICT_FALSE(!ref_result.ok())) {
+ error = std::move(ref_result).error();
+ return;
}
+ weak_copy.update(std::weak_ptr<T>(ref_result.value()));
});
}
};
diff --git a/cpp/fory/serialization/weak_ptr_serializer_test.cc
b/cpp/fory/serialization/weak_ptr_serializer_test.cc
index 0764fce3a..dceb5689d 100644
--- a/cpp/fory/serialization/weak_ptr_serializer_test.cc
+++ b/cpp/fory/serialization/weak_ptr_serializer_test.cc
@@ -171,6 +171,50 @@ struct NodeWithParent {
FORY_STRUCT(NodeWithParent, value, parent, children);
};
+TEST(WeakPtrSerializerTest, RejectsResolvedTypeMismatch) {
+ Config config;
+ config.track_ref = true;
+ ReadContext ctx(config, std::make_unique<TypeResolver>());
+ ctx.ref_reader().store_shared_ref_at(0, std::make_shared<int32_t>(42));
+ Buffer buffer;
+ buffer.write_int8(REF_FLAG);
+ buffer.write_var_uint32(0);
+ ctx.attach(buffer);
+
+ auto result =
+ Serializer<SharedWeak<SimpleStruct>>::read(ctx, RefMode::Tracking,
false);
+
+ EXPECT_TRUE(result.expired());
+ ASSERT_TRUE(ctx.has_error());
+ EXPECT_EQ(ctx.error().code(), ErrorCode::InvalidRef);
+ EXPECT_NE(ctx.error().message().find("Reference type mismatch"),
+ std::string::npos);
+}
+
+TEST(WeakPtrSerializerTest, RejectsForwardTypeMismatch) {
+ Config config;
+ config.track_ref = true;
+ ReadContext ctx(config, std::make_unique<TypeResolver>());
+ uint32_t ref_id = ctx.ref_reader().reserve_ref_id();
+ Buffer buffer;
+ buffer.write_int8(REF_FLAG);
+ buffer.write_var_uint32(ref_id);
+ ctx.attach(buffer);
+
+ auto result =
+ Serializer<SharedWeak<SimpleStruct>>::read(ctx, RefMode::Tracking,
false);
+ ASSERT_FALSE(ctx.has_error());
+ EXPECT_TRUE(result.expired());
+
+ ctx.ref_reader().store_shared_ref_at(ref_id, std::make_shared<int32_t>(42));
+ ctx.ref_reader().resolve_callbacks(ctx.error());
+
+ ASSERT_TRUE(ctx.has_error());
+ EXPECT_EQ(ctx.error().code(), ErrorCode::InvalidRef);
+ EXPECT_NE(ctx.error().message().find("Reference type mismatch"),
+ std::string::npos);
+}
+
// ============================================================================
// Serialization Tests
// ============================================================================
diff --git a/docs/guide/cpp/custom-serializers.md
b/docs/guide/cpp/custom-serializers.md
index 60b969ae6..8fe4d4353 100644
--- a/docs/guide/cpp/custom-serializers.md
+++ b/docs/guide/cpp/custom-serializers.md
@@ -191,7 +191,7 @@ struct Serializer<CustomType> {
write_not_null_ref_flag(ctx, ref_mode);
if (write_type) {
auto result = ctx.write_any_type_info(
- static_cast<uint32_t>(TypeId::UNKNOWN),
+ static_cast<uint32_t>(type_id),
std::type_index(typeid(CustomType)));
if (!result.ok()) {
ctx.set_error(std::move(result).error());
diff --git a/docs/guide/cpp/polymorphism.md b/docs/guide/cpp/polymorphism.md
index 3c9bbb3ff..b28f0eb04 100644
--- a/docs/guide/cpp/polymorphism.md
+++ b/docs/guide/cpp/polymorphism.md
@@ -48,13 +48,13 @@ struct Dog : Animal {
std::string speak() const override { return "Woof!"; }
std::string breed;
};
-FORY_STRUCT(Dog, age, breed);
+FORY_STRUCT(Dog, FORY_BASE(Animal), breed);
struct Cat : Animal {
std::string speak() const override { return "Meow!"; }
std::string color;
};
-FORY_STRUCT(Cat, age, color);
+FORY_STRUCT(Cat, FORY_BASE(Animal), color);
// Struct with polymorphic field
struct Zoo {
@@ -337,7 +337,7 @@ FORY_STRUCT(GraphNode, id, neighbors);
struct WeightedNode : GraphNode {
double weight = 0.0;
};
-FORY_STRUCT(WeightedNode, id, neighbors, weight);
+FORY_STRUCT(WeightedNode, FORY_BASE(GraphNode), weight);
// Enable ref tracking to handle shared references and cycles
auto fory = Fory::builder().xlang(true).track_ref(true).build();
@@ -392,14 +392,25 @@ auto fory = Fory::builder()
};
```
-4. **Register all concrete types** before serialization/deserialization:
+4. **Declare every serialized base relationship** with `FORY_BASE`:
+
+ ```cpp
+ FORY_STRUCT(DerivedType, FORY_BASE(BaseType), derived_field);
+ ```
+
+ This lets Fory validate polymorphic values and correctly adjust pointers for
+ multiple inheritance during deserialization. A derived value whose base
+ relationship is not declared cannot be deserialized through that base smart
+ pointer type.
+
+5. **Register all concrete types** before serialization/deserialization:
```cpp
fory.register_struct<Derived1>(100);
fory.register_struct<Derived2>(101);
```
-5. **Use `dynamic_cast`** to downcast after deserialization:
+6. **Use `dynamic_cast`** to downcast after deserialization:
```cpp
auto* derived = dynamic_cast<DerivedType*>(base_ptr.get());
@@ -408,13 +419,13 @@ auto fory = Fory::builder()
}
```
-6. **Adjust `max_dyn_depth`** based on your data structure depth:
+7. **Adjust `max_dyn_depth`** based on your data structure depth:
```cpp
auto fory = Fory::builder().xlang(true).max_dyn_depth(10).build();
```
-7. **Use `nullable()`** for optional polymorphic fields:
+8. **Use `nullable()`** for optional polymorphic fields:
```cpp
FORY_STRUCT(Holder, (optional_ptr, fory::F().nullable()));
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]