29#ifndef A11_DATA_SERIALIZATION_H_
30#define A11_DATA_SERIALIZATION_H_
42#include <absl/base/nullability.h>
43#include <absl/status/status.h>
44#include <absl/status/status_macros.h>
45#include <absl/status/statusor.h>
46#include <absl/strings/str_cat.h>
75inline constexpr std::string_view
kBytesMimetype =
"application/octet-stream";
104 std::shared_ptr<const SerializationRegistry> registry)
105 : value_(std::move(
value)),
106 tag_(std::move(
tag)),
108 registry_(std::move(registry)) {}
110 [[nodiscard]] std::string_view
tag()
const override {
return tag_; }
112 [[nodiscard]] std::string_view
mimetype()
const override {
return mimetype_; }
114 [[nodiscard]]
const void* absl_nonnull
address()
const override {
118 [[nodiscard]]
const T&
value()
const {
return value_; }
120 [[nodiscard]] absl::StatusOr<Bytes>
Encode()
const override;
126 return sizeof(T) + 64;
131 const std::string tag_;
132 const std::string mimetype_;
133 const std::shared_ptr<const SerializationRegistry> registry_;
145 if (chunk.
object ==
nullptr || chunk.
object->tag() != tag) {
150 return typed ==
nullptr ? std::nullopt : std::optional<T>(typed->
value());
167 template <
typename T>
168 using Serializer = std::function<absl::StatusOr<Chunk>(
const T&)>;
171 template <
typename T>
183 template <
typename T>
188 return absl::InvalidArgumentError(
"serializer must be callable");
190 return RegisterSerializerErased(
192 [serializer = std::move(serializer)](
193 const void* absl_nonnull
value) -> absl::StatusOr<Chunk> {
194 if (
value ==
nullptr) {
195 return absl::InvalidArgumentError(
"serializer value is null");
200 absl::StatusOr<Chunk> chunk;
202 [&] { chunk = serializer(*
static_cast<const T*
>(
value)); },
220 template <
typename T>
225 return absl::InvalidArgumentError(
"deserializer must be callable");
227 return RegisterDeserializerErased(
229 [deserializer = std::move(deserializer)](
230 const Chunk& chunk) -> absl::StatusOr<std::any> {
234 [&] {
result = deserializer(chunk); },
"deserializer");
241 return std::any(std::move(*
result));
259 template <
typename T>
263 ABSL_RETURN_IF_ERROR(
264 RegisterSerializer<T>(type_name,
mimetype, std::move(serializer)));
265 absl::Status status =
266 RegisterDeserializer<T>(type_name,
mimetype, std::move(deserializer));
268 RemoveSerializer(
typeid(T), type_name,
mimetype);
271 return absl::OkStatus();
282 template <
typename T>
284 std::string_view
mimetype = {})
const {
299 template <
typename T>
302 const std::vector<std::string>& mimetype_patterns = {})
const {
303 ABSL_ASSIGN_OR_RETURN(std::any
result,
304 FromChunkErased(chunk,
typeid(T), mimetype_patterns));
307 T* absl_nullable
value = std::any_cast<T>(&
result);
308 if (
value ==
nullptr) {
309 return absl::InternalError(
310 absl::StrCat(
"A deserializer produced ",
result.type().name(),
311 ", which is not the requested ",
typeid(T).name()));
313 return std::move(*
value);
324 using ErasedSerializer =
325 std::function<absl::StatusOr<Chunk>(
const void* absl_nonnull
value)>;
326 using ErasedDeserializer =
327 std::function<absl::StatusOr<std::any>(
const Chunk& chunk)>;
329 struct SerializerRegistration;
330 struct DeserializerRegistration;
333 static constexpr size_t kImplSize = 192;
334 static constexpr size_t kImplAlignment =
alignof(std::max_align_t);
336 Impl* absl_nonnull GetImpl();
337 [[nodiscard]]
const Impl* absl_nonnull GetImpl()
const;
339 absl::Status RegisterSerializerErased(std::type_index
type,
340 std::string_view type_name,
342 ErasedSerializer serializer);
343 absl::Status RegisterDeserializerErased(std::type_index
type,
344 std::string_view type_name,
346 ErasedDeserializer deserializer);
347 void RemoveSerializer(std::type_index
type, std::string_view type_name,
350 absl::StatusOr<Chunk> ToChunkErased(std::type_index
type,
351 const void* absl_nonnull
value,
353 absl::StatusOr<std::any> FromChunkErased(
354 const Chunk& chunk, std::type_index requested_type,
355 const std::vector<std::string>& mimetype_patterns)
const;
357 alignas(kImplAlignment) std::byte impl_[kImplSize];
365 if (registry_ ==
nullptr) {
366 return absl::FailedPreconditionError(
367 absl::StrCat(
"a chunk carrying a ", tag_,
368 " was asked for its bytes, but no serialization registry "
371 ABSL_ASSIGN_OR_RETURN(
Chunk encoded,
372 registry_->ToChunk<T>(value_, mimetype_));
373 return std::move(encoded.
data);
388 std::shared_ptr<const SerializationRegistry> registry) {
394 chunk.
object = std::make_shared<const TypedChunkObject<T>>(
396 std::move(registry));
a11::Promise< a11::Unit > result
Definition async_node.cc:56
An in-process value a chunk may carry instead of its encoded bytes.
Definition types.h:140
Definition serialization.h:153
absl::Status RegisterDefaults()
Installs the standard JSON and MessagePack codecs.
Definition serialization.cc:493
size_t serializer_count() const
Number of registered serializers.
Definition serialization.cc:511
std::function< absl::StatusOr< Chunk >(const T &)> Serializer
Callable turning a T into a Chunk.
Definition serialization.h:168
SerializationRegistry & operator=(const SerializationRegistry &)=delete
std::function< absl::StatusOr< T >(const Chunk &)> Deserializer
Callable reconstructing a T from a Chunk.
Definition serialization.h:172
absl::StatusOr< Chunk > ToChunk(const T &value, std::string_view mimetype={}) const
Serializes value into a Chunk.
Definition serialization.h:283
absl::Status RegisterSerializer(std::string_view type_name, std::string_view mimetype, Serializer< T > serializer)
Registers a serializer for type T and an exact media type.
Definition serialization.h:184
size_t deserializer_count() const
Number of registered deserializers.
Definition serialization.cc:517
absl::Status Register(std::string_view type_name, std::string_view mimetype, Serializer< T > serializer, Deserializer< T > deserializer)
Atomically registers a serializer/deserializer pair for T.
Definition serialization.h:260
~SerializationRegistry()
Definition serialization.cc:275
absl::Status RegisterDeserializer(std::string_view type_name, std::string_view mimetype, Deserializer< T > deserializer)
Registers a deserializer for type T and an exact media type.
Definition serialization.h:221
absl::StatusOr< T > FromChunk(const Chunk &chunk, const std::vector< std::string > &mimetype_patterns={}) const
Deserializes chunk into a value of type T.
Definition serialization.h:300
SerializationRegistry(const SerializationRegistry &)=delete
The local fast path: a value in a chunk, encoded only if needed.
Definition serialization.h:101
size_t ApproxBytes() const override
A size estimate that does not encode anything.
Definition serialization.h:122
std::string_view tag() const override
The serialisation tag of the held type.
Definition serialization.h:110
TypedChunkObject(T value, std::string tag, std::string mimetype, std::shared_ptr< const SerializationRegistry > registry)
Definition serialization.h:103
std::string_view mimetype() const override
The mimetype the value would be encoded as.
Definition serialization.h:112
absl::StatusOr< Bytes > Encode() const override
Encodes the value, for whoever needs bytes after all.
Definition serialization.h:364
const void *absl_nonnull address() const override
An opaque address supplied by the object implementation.
Definition serialization.h:114
const T & value() const
Definition serialization.h:118
std::string value
Definition discover.cc:100
Turns what a caller's callable throws into a Status, at the boundary.
constexpr std::string_view kBytesMimetype
Media type of opaque bytes carried as themselves.
Definition serialization.h:75
constexpr std::string_view kJsonMimetype
Media type of the built-in JSON codec.
Definition serialization.h:54
constexpr std::string_view kTextMimetype
Media type of UTF-8 text carried as itself.
Definition serialization.h:65
SerializationRegistry & GlobalSerializationRegistry()
Returns the process-wide registry (defaults pre-installed).
Definition serialization.cc:523
constexpr std::string_view kMsgpackMimetype
Media type of the built-in MessagePack codec.
Definition serialization.h:56
Chunk MakeChunkObject(T value, std::string tag, std::string mimetype, std::shared_ptr< const SerializationRegistry > registry)
Builds a chunk carrying value, with no bytes produced.
Definition serialization.h:387
std::optional< T > TryTakeObject(const Chunk &chunk, std::string_view tag)
Takes the value out of chunk, if it is carrying one of type T.
Definition serialization.h:144
absl::Status Attempt(Callable &&callable, std::string_view what)
Runs callable, reporting anything it throws as a Status.
Definition exception_guard.h:114
std::string mimetype
Definition sqlite_chunk_store.cc:191
A unit of data: bytes plus optional descriptive metadata.
Definition types.h:173
std::optional< ChunkMetadata > metadata
Optional payload metadata.
Definition types.h:174
Bytes data
Inline byte payload.
Definition types.h:176
std::shared_ptr< const ChunkObject > object
The value this chunk stands for, when its bytes have not been produced.
Definition types.h:184
A11's core wire value types: chunks, node fragments and messages.