serializable.h

Go to the documentation of this file.

/*
 * Copyright 2026 The A11 Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef A11_DATA_SERIALIZABLE_H_
#define A11_DATA_SERIALIZABLE_H_
 
#include <cstdint>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include <absl/status/status.h>
#include <absl/status/status_macros.h>
#include <absl/status/statusor.h>
#include <absl/strings/str_cat.h>
#include <nlohmann/json.hpp>
 
#include "a11/data/serial_tags.h"
#include "a11/data/serialization.h"
#include "a11/data/types.h"
#include "a11/json_codec.h"
 
namespace a11::data {
 
template <typename T>
struct TypeTag {};
 
// The runtime's own types answer the same customization point every other
// serializable type does, with the canonical tags from a11/data/serial_tags.h.
inline std::string_view A11SerialTag(TypeTag<ChunkMetadata>) {
  return kChunkMetadataTag;
}
 
inline std::string_view A11SerialTag(TypeTag<Chunk>) {
  return kChunkTag;
}
 
inline std::string_view A11SerialTag(TypeTag<NodeRef>) {
  return kNodeRefTag;
}
 
inline std::string_view A11SerialTag(TypeTag<NodeFragment>) {
  return kNodeFragmentTag;
}
 
inline std::string_view A11SerialTag(TypeTag<Port>) {
  return kPortTag;
}
 
inline std::string_view A11SerialTag(TypeTag<ActionMessage>) {
  return kActionMessageTag;
}
 
inline std::string_view A11SerialTag(TypeTag<WireMessage>) {
  return kWireMessageTag;
}
 
namespace serializable_internal {
 
// Unqualified calls so ADL locates the customization points in T's namespace.
 
template <typename T>
concept HasSerialTag = requires {
  {A11SerialTag(TypeTag<T>{})}->std::convertible_to<std::string_view>;
};
 
template <typename T>
concept HasJson = requires(const T& value, const nlohmann::json& json) {
  {A11ToJson(value)}->std::same_as<absl::StatusOr<nlohmann::json>>;
  {A11FromJson(TypeTag<T>{}, json)}->std::same_as<absl::StatusOr<T>>;
};
 
template <typename T>
concept HasMsgpackBytes = requires(const T& value, std::string_view bytes) {
  {A11ToMsgpackBytes(value)}->std::same_as<absl::StatusOr<std::string>>;
  {A11FromMsgpackBytes(TypeTag<T>{}, bytes)}->std::same_as<absl::StatusOr<T>>;
};
 
template <typename T>
std::string SerialTag() {
  return std::string(A11SerialTag(TypeTag<T>{}));
}
 
}  // namespace serializable_internal
 
template <typename T>
concept JsonSerializable =
    serializable_internal::HasSerialTag<T> && serializable_internal::HasJson<T>;
 
template <typename T>
concept MsgpackSerializable = serializable_internal::HasSerialTag<T> &&
                              (serializable_internal::HasMsgpackBytes<T> ||
                               serializable_internal::HasJson<T>);
 
template <typename T>
concept Serializable = JsonSerializable<T> || MsgpackSerializable<T>;
 
template <typename T>
concept HasSerialTypeTag = serializable_internal::HasSerialTag<T>;
 
template <typename T>
requires serializable_internal::HasSerialTag<T> std::string SerialTypeTag() {
  return serializable_internal::SerialTag<T>();
}
 
template <typename T>
requires JsonSerializable<T> absl::Status RegisterJsonSerializable(
    SerializationRegistry& registry) {
  return registry.Register<T>(
      serializable_internal::SerialTag<T>(), std::string(kJsonMimetype),
      [](const T& value) -> absl::StatusOr<Chunk> {
        ABSL_ASSIGN_OR_RETURN(nlohmann::json json, A11ToJson(value));
        ABSL_ASSIGN_OR_RETURN(std::string encoded, DumpJson(json, "JSON"));
        return Chunk{.data = std::move(encoded)};
      },
      [](const Chunk& chunk) -> absl::StatusOr<T> {
        ABSL_ASSIGN_OR_RETURN(const nlohmann::json json,
                              ParseJson(chunk.data, "JSON data"));
        return A11FromJson(TypeTag<T>{}, json);
      });
}
 
template <typename T>
requires MsgpackSerializable<T> absl::Status RegisterMsgpackSerializable(
    SerializationRegistry& registry) {
  if constexpr (serializable_internal::HasMsgpackBytes<T>) {
    return registry.Register<T>(
        serializable_internal::SerialTag<T>(), std::string(kMsgpackMimetype),
        [](const T& value) -> absl::StatusOr<Chunk> {
          ABSL_ASSIGN_OR_RETURN(std::string bytes, A11ToMsgpackBytes(value));
          return Chunk{.data = std::move(bytes)};
        },
        [](const Chunk& chunk) -> absl::StatusOr<T> {
          return A11FromMsgpackBytes(TypeTag<T>{}, chunk.data);
        });
  } else {
    // Derive MessagePack from the JSON representation.
    return registry.Register<T>(
        serializable_internal::SerialTag<T>(), std::string(kMsgpackMimetype),
        [](const T& value) -> absl::StatusOr<Chunk> {
          ABSL_ASSIGN_OR_RETURN(nlohmann::json json, A11ToJson(value));
          ABSL_ASSIGN_OR_RETURN(std::string encoded, PackMsgpack(json, "JSON"));
          return Chunk{.data = std::move(encoded)};
        },
        [](const Chunk& chunk) -> absl::StatusOr<T> {
          ABSL_ASSIGN_OR_RETURN(const nlohmann::json json,
                                UnpackMsgpack(chunk.data, "JSON"));
          return A11FromJson(TypeTag<T>{}, json);
        });
  }
}
 
template <typename T>
requires Serializable<T> absl::Status RegisterSerializable(
    SerializationRegistry& registry, bool json = true, bool msgpack = true) {
  if (json && JsonSerializable<T>) {
    if constexpr (JsonSerializable<T>) {
      ABSL_RETURN_IF_ERROR(RegisterJsonSerializable<T>(registry));
    }
  }
  if (msgpack && MsgpackSerializable<T>) {
    if constexpr (MsgpackSerializable<T>) {
      ABSL_RETURN_IF_ERROR(RegisterMsgpackSerializable<T>(registry));
    }
  }
  return absl::OkStatus();
}
 
}  // namespace a11::data
 
#endif  // A11_DATA_SERIALIZABLE_H_