serializer-inl.h

Go to the documentation of this file.

/*
 * Copyright (C) 2026 by Thun Lu. All rights reserved.
 * Author: Thun Lu <thun.lu@zohomail.cn>
 * Repo:   https://github.com/thun-res/vlink
 *  _    __   __      _           __
 * | |  / /  / /     (_) ____    / /__
 * | | / /  / /     / / / __ \  / //_/
 * | |/ /  / /___  / / / / / / / ,<
 * |___/  /_____/ /_/ /_/ /_/ /_/|_|
 *
 * 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.
 */
 
#pragma once
 
#include <cstring>
#include <exception>
#include <limits>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
 
#include "../base/helpers.h"
#include "../base/logger.h"
#include "../base/name_detector.h"
#include "../base/traits.h"
#include "../serializer.h"
 
#ifndef VLINK_DDS_IDL_PREFIX
#define VLINK_DDS_IDL_PREFIX "dds::"
#endif
 
#if defined(VLINK_SUPPORT_CDR) || defined(VLINK_SUPPORT_ROS2)
#if __has_include(<fastcdr/Cdr.h>)
#include <fastcdr/Cdr.h>
#if FASTCDR_VERSION_MAJOR >= 2
#include <fastcdr/CdrSizeCalculator.hpp>
#endif
#ifndef VLINK_HAS_CDR
#define VLINK_HAS_CDR
#endif
#else
#warning "Fast CDR headers are required when CDR serialization support is enabled."
#endif
#endif
 
#ifdef VLINK_SUPPORT_ROS2
#if defined(VLINK_HAS_CDR) && __has_include(<rosidl_typesupport_fastrtps_cpp/message_type_support.h>)
#include <rosidl_typesupport_fastrtps_cpp/message_type_support.h>
 
#include <rosidl_runtime_cpp/traits.hpp>
#include <rosidl_typesupport_fastrtps_cpp/message_type_support_decl.hpp>
#ifndef VLINK_HAS_ROS2
#define VLINK_HAS_ROS2
#endif
#elif defined(VLINK_HAS_CDR)
#warning "ROS 2 message headers are required when ROS 2 message support is enabled."
#endif
#endif
 
#if __has_include(<google/protobuf/message_lite.h>)
#ifndef VLINK_HAS_PROTOBUF
#define VLINK_HAS_PROTOBUF
#endif
#include <google/protobuf/message_lite.h>
#endif
 
#if __has_include(<flatbuffers/flatbuffers.h>)
#ifndef VLINK_HAS_FLATBUFFERS
#define VLINK_HAS_FLATBUFFERS
#endif
#include <flatbuffers/flatbuffers.h>
#endif
 
namespace vlink {
 
namespace Serializer {  // NOLINT(readability-identifier-naming)
 
[[maybe_unused]] inline constexpr bool is_supported(Type type) noexcept { return type != kUnknownType; }
 
#ifdef VLINK_HAS_ROS2
template <typename T>
inline constexpr bool is_ros2_msg_type() noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  return rosidl_generator_traits::is_message<RealType>::value;
}
 
template <typename T>
inline const message_type_support_callbacks_t* get_ros2_msg_callbacks() noexcept {
  const auto* type_support = rosidl_typesupport_fastrtps_cpp::get_message_type_support_handle<T>();
  return type_support ? static_cast<const message_type_support_callbacks_t*>(type_support->data) : nullptr;
}
#endif
 
template <typename T>
inline constexpr Type get_type_of() noexcept {
  if constexpr (is_bytes_type<T>()) {
    return kBytesType;
  } else if constexpr (is_dynamic_type<T>()) {
    return kDynamicType;
#ifdef VLINK_HAS_CDR
  } else if constexpr (is_cdr_type<T>()) {
    return kCdrType;
#endif
#ifdef VLINK_HAS_PROTOBUF
  } else if constexpr (is_proto_type<T>()) {
    return kProtoType;
  } else if constexpr (is_proto_ptr_type<T>()) {
    return kProtoPtrType;
#endif
#ifdef VLINK_HAS_FLATBUFFERS
  } else if constexpr (is_flat_table_type<T>()) {
    return kFlatTableType;
  } else if constexpr (is_flat_ptr_type<T>()) {
    return kFlatPtrType;
  } else if constexpr (is_flat_builder_type<T>()) {
    return kFlatBuilderType;
#endif
  } else if constexpr (is_custom_type<T>()) {
    return kCustomType;
  } else if constexpr (is_string_type<T>()) {
    return kStringType;
  } else if constexpr (is_chars_type<T>()) {
    return kCharsType;
  } else if constexpr (is_standard_type<T>()) {
    return kStandardType;
  } else if constexpr (is_standard_ptr_type<T>()) {
    return kStandardPtrType;
  } else if constexpr (is_stream_type<T>()) {
    return kStreamType;
  } else {
    return kUnknownType;
  }
}
 
template <Type TypeT, typename T>
inline static constexpr SchemaType get_schema_type() noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
 
  if constexpr (TypeT == kBytesType) {
    return SchemaType::kRaw;
  } else if constexpr (TypeT == kCustomType) {
    if constexpr (VLINK_HAS_MEMBER(RealType, kZerocopyTypes)) {
      if constexpr (RealType::kZerocopyTypes) {
        return SchemaType::kZeroCopy;
      } else {
        return SchemaType::kRaw;
      }
    } else if constexpr (VLINK_HAS_MEMBER(RealType, get_schema_type())) {
      return RealType::get_schema_type();
    } else {
      return SchemaType::kRaw;
    }
#ifdef VLINK_HAS_PROTOBUF
  } else if constexpr (TypeT == kProtoType || TypeT == kProtoPtrType) {
    return SchemaType::kProtobuf;
#endif
#ifdef VLINK_HAS_FLATBUFFERS
  } else if constexpr (TypeT == kFlatTableType || TypeT == kFlatPtrType || TypeT == kFlatBuilderType) {
    return SchemaType::kFlatbuffers;
#endif
#ifdef VLINK_HAS_CDR
  } else if constexpr (TypeT == kCdrType) {
    return SchemaType::kCdr;
#endif
  } else {
    return SchemaType::kRaw;
  }
}
 
template <typename T>
inline static constexpr SchemaType get_schema_type() noexcept {
  constexpr auto kType = get_type_of<T>();
 
  return get_schema_type<kType, T>();
}
 
template <Type TypeT, typename T>
inline std::string get_serialized_type() noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  using NamedType = std::remove_pointer_t<RealType>;
 
  if constexpr (TypeT == kBytesType) {
    return "";
  } else if constexpr (TypeT == kDynamicType) {
    return "vlink::DynamicData";
  } else if constexpr (TypeT == kCustomType && VLINK_HAS_MEMBER(RealType, get_serialized_type())) {
    return RealType::get_serialized_type();
#ifdef VLINK_HAS_PROTOBUF
  } else if constexpr (TypeT == kProtoType || TypeT == kProtoPtrType) {
    return std::string(NamedType{}.GetTypeName());
#endif
#ifdef VLINK_HAS_FLATBUFFERS
  } else if constexpr (TypeT == kFlatTableType) {
    using TableType = typename RealType::TableType;
    if constexpr (VLINK_HAS_MEMBER(TableType, GetFullyQualifiedName)) {
      return TableType::GetFullyQualifiedName();
    } else {
      std::string name = NameDetector::get<TableType>().data();
      Helpers::replace_string(name, "::", ".");
      return name;
    }
  } else if constexpr (TypeT == kFlatBuilderType) {
    using TableType = typename RealType::Table;
    if constexpr (VLINK_HAS_MEMBER(TableType, GetFullyQualifiedName)) {
      return TableType::GetFullyQualifiedName();
    } else {
      std::string name = NameDetector::get<TableType>().data();
      Helpers::replace_string(name, "::", ".");
      return name;
    }
  } else if constexpr (TypeT == kFlatPtrType) {
    using TableType = std::remove_pointer_t<T>;
    if constexpr (VLINK_HAS_MEMBER(TableType, GetFullyQualifiedName)) {
      return TableType::GetFullyQualifiedName();
    } else {
      std::string name = NameDetector::get<TableType>().data();
      Helpers::replace_string(name, "::", ".");
      return name;
    }
#endif
#ifdef VLINK_HAS_ROS2
  } else if constexpr (TypeT == kCdrType && is_ros2_msg_type<RealType>()) {
    const auto* callbacks = get_ros2_msg_callbacks<RealType>();
 
    if VUNLIKELY (!callbacks || !callbacks->message_namespace_ || !callbacks->message_name_) {
      return "";
    }
 
    std::string name(callbacks->message_namespace_);
    name.append("::dds_::").append(callbacks->message_name_).append("_");
 
    return name;
#endif
  } else if constexpr (TypeT == kStringType || TypeT == kCharsType) {
    return "string";
  } else if constexpr (NameDetector::is_support<NamedType>()) {
    return NameDetector::get<NamedType>().data();
  } else {
    return "";
  }
}
 
template <typename T>
inline std::string get_serialized_type() noexcept {
  constexpr auto kType = get_type_of<T>();
 
  return get_serialized_type<kType, T>();
}
 
template <Type TypeT, typename T>
inline size_t get_serialized_size(const T& src) noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
 
  if constexpr (TypeT == kBytesType) {
    return 0;
  } else if constexpr (TypeT == kDynamicType) {
    return 0;
#ifdef VLINK_HAS_CDR
  } else if constexpr (TypeT == kCdrType) {
    try {
#ifdef VLINK_HAS_ROS2
      if constexpr (is_ros2_msg_type<RealType>()) {
        const auto* callbacks = get_ros2_msg_callbacks<RealType>();
 
        if VUNLIKELY (!callbacks || !callbacks->get_serialized_size) {
          return 0U;
        }
 
        const size_t payload_size = callbacks->get_serialized_size(&deref(src));
        return payload_size <= std::numeric_limits<uint32_t>::max() - 4U ? payload_size + 4U : 0U;
      } else {
#endif
        if constexpr (VLINK_HAS_MEMBER(RealType, getCdrSerializedSize(deref(src)))) {
          const size_t payload_size = RealType::getCdrSerializedSize(deref(src));
          return payload_size <= std::numeric_limits<uint32_t>::max() - 4U ? payload_size + 4U : 0U;
#if FASTCDR_VERSION_MAJOR >= 2
        } else {
          eprosima::fastcdr::CdrSizeCalculator calculator(eprosima::fastcdr::CdrVersion::XCDRv1);
          size_t current_alignment = 0;
          const size_t payload_size = calculator.calculate_serialized_size(deref(src), current_alignment);
          return payload_size <= std::numeric_limits<uint32_t>::max() - 4U ? payload_size + 4U : 0U;
#else
      } else {
        return 0;
#endif
        }
#ifdef VLINK_HAS_ROS2
      }
#endif
    } catch (const std::exception&) {
      return 0;
    }
#endif
#ifdef VLINK_HAS_PROTOBUF
  } else if constexpr (TypeT == kProtoType) {
    if constexpr (VLINK_HAS_MEMBER(RealType, ByteSizeLong())) {
      return deref(src).ByteSizeLong();
    } else {
      return deref(src).ByteSize();
    }
  } else if constexpr (TypeT == kProtoPtrType) {
    if constexpr (VLINK_HAS_MEMBER(std::remove_pointer_t<T>, ByteSizeLong())) {
      return src->ByteSizeLong();
    } else {
      return src->ByteSize();
    }
#endif
  } else if constexpr (TypeT == kCustomType) {
    if constexpr (VLINK_HAS_MEMBER(RealType, get_serialized_size())) {
      return deref(src).get_serialized_size();
    } else {
      return 0;
    }
  } else {
    return 0;
  }
}
 
template <typename T>
inline size_t get_serialized_size(const T& src) noexcept {
  constexpr auto kType = get_type_of<T>();
 
  return get_serialized_size<kType>(src);
}
 
template <Type TypeT, typename T>
inline bool serialize(const T& src, Bytes& des, [[maybe_unused]] TransportType transport,
                      [[maybe_unused]] uint8_t offset) {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
 
  if constexpr (TypeT == kBytesType) {
    des = Bytes::deep_copy(src.data(), src.size(), offset);
  } else if constexpr (TypeT == kDynamicType) {
    using ReturnT = decltype(deref(src) >> des);
 
    if constexpr (std::is_convertible_v<ReturnT, bool>) {
      if VUNLIKELY (!(deref(src) >> des)) {
        VLOG_T("Serializer: Dynamic serialize failed.");
        return false;
      }
    } else {
      deref(src) >> des;
    }
#ifdef VLINK_HAS_CDR
  } else if constexpr (TypeT == kCdrType) {
    const size_t target_size = get_serialized_size<TypeT>(src);
 
    if VUNLIKELY (target_size < 4U || target_size > std::numeric_limits<uint32_t>::max()) {
      VLOG_W("Serializer: FastBuffer serialized size is invalid.");
      return false;
    }
 
    if (!des.is_loaned()) {
      if VUNLIKELY (des.size() != target_size) {
        des = Bytes::create(target_size, offset);
      }
    }
 
    if VUNLIKELY (!des.data() || des.size() != target_size) {
      return false;
    }
 
    try {
      eprosima::fastcdr::FastBuffer buffer(reinterpret_cast<char*>(des.data()), des.size());
#if FASTCDR_VERSION_MAJOR >= 2
      constexpr auto kCdrVersion = VLINK_HAS_MEMBER(RealType, serialize(std::declval<eprosima::fastcdr::Cdr&>()))
                                       ? eprosima::fastcdr::CdrVersion::DDS_CDR
                                       : eprosima::fastcdr::CdrVersion::XCDRv1;
      eprosima::fastcdr::Cdr cdr(buffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, kCdrVersion);
      if constexpr (kCdrVersion == eprosima::fastcdr::CdrVersion::XCDRv1) {
        cdr.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR);
      }
#else
      eprosima::fastcdr::Cdr cdr(buffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, eprosima::fastcdr::Cdr::DDS_CDR);
#endif
      cdr.serialize_encapsulation();
 
#ifdef VLINK_HAS_ROS2
      if constexpr (is_ros2_msg_type<RealType>()) {
        const auto* callbacks = get_ros2_msg_callbacks<RealType>();
 
        if VUNLIKELY (!callbacks || !callbacks->cdr_serialize || !callbacks->cdr_serialize(&deref(src), cdr)) {
          return false;
        }
      } else {
#endif
        if constexpr (VLINK_HAS_MEMBER(RealType, serialize(cdr))) {
          deref(src).serialize(cdr);
#if FASTCDR_VERSION_MAJOR >= 2
        } else {
          cdr << deref(src);
#endif
        }
#ifdef VLINK_HAS_ROS2
      }
#endif
    } catch (const eprosima::fastcdr::exception::Exception& e) {
      VLOG_T("Serializer: FastBuffer serialize failed: ", e.what(), ".");
      return false;
    } catch (const std::exception& e) {
      VLOG_T("Serializer: CDR serialize failed: ", e.what(), ".");
      return false;
    }
#endif
#ifdef VLINK_HAS_PROTOBUF
  } else if constexpr (TypeT == kProtoType) {
    if (!des.is_loaned()) {
      if constexpr (VLINK_HAS_MEMBER(RealType, ByteSizeLong())) {
        size_t target_size = deref(src).ByteSizeLong();
 
        if VUNLIKELY (des.size() != target_size) {
          des = Bytes::create(target_size, offset);
        }
      } else {
        size_t target_size = deref(src).ByteSize();
 
        if VUNLIKELY (des.size() != target_size) {
          des = Bytes::create(target_size, offset);
        }
      }
    }
 
    if VUNLIKELY (!deref(src).SerializeToArray(des.data(), des.size())) {
      VLOG_T("Serializer: Protobuf serialize failed.");
      return false;
    }
  } else if constexpr (TypeT == kProtoPtrType) {
    if (!des.is_loaned()) {
      if constexpr (VLINK_HAS_MEMBER(std::remove_pointer_t<T>, ByteSizeLong())) {
        size_t target_size = src->ByteSizeLong();
 
        if VUNLIKELY (des.size() != target_size) {
          des = Bytes::create(target_size, offset);
        }
      } else {
        size_t target_size = src->ByteSize();
 
        if VUNLIKELY (des.size() != target_size) {
          des = Bytes::create(target_size, offset);
        }
      }
    }
 
    if VUNLIKELY (!src->SerializeToArray(des.data(), des.size())) {
      VLOG_T("Serializer: Protobuf ptr serialize failed.");
      return false;
    }
#endif
#ifdef VLINK_HAS_FLATBUFFERS
  } else if constexpr (TypeT == kFlatTableType) {
    flatbuffers::FlatBufferBuilder fbb;
    fbb.Finish(RealType::TableType::Pack(fbb, &deref(src)));
 
    if (des.is_loaned() && des.size() >= fbb.GetSize() + offset) {
      std::memcpy(des.data() + offset, fbb.GetBufferPointer(), fbb.GetSize());
    } else {
      des = Bytes::deep_copy(fbb.GetBufferPointer(), fbb.GetSize(), offset);
    }
  } else if constexpr (TypeT == kFlatBuilderType) {
    if VUNLIKELY (des.is_loaned()) {
      return false;
    }
 
    auto& mutable_src = const_cast<T&>(src);
    mutable_src.fbb_.Finish(mutable_src.Finish());
    des = Bytes::deep_copy(mutable_src.fbb_.GetBufferPointer(), mutable_src.fbb_.GetSize(), offset);
  } else if constexpr (TypeT == kFlatPtrType) {
    static_assert(Traits::ExpectFalse<T>(), "Not support flat ptr type.");
#endif
  } else if constexpr (TypeT == kCustomType) {
    using ReturnT = decltype(const_cast<RealType&>(deref(src)) >> des);
 
    if constexpr (std::is_convertible_v<ReturnT, bool>) {
      if VUNLIKELY (!(const_cast<RealType&>(deref(src)) >> des)) {
        VLOG_T("Serializer: Custom serialize failed.");
        return false;
      }
    } else {
      const_cast<RealType&>(deref(src)) >> des;
    }
 
    if (offset > 0) {
      des = Bytes::deep_copy(des.data(), des.size(), offset);
    }
  } else if constexpr (TypeT == kStringType) {
    des = Bytes::deep_copy(reinterpret_cast<const uint8_t*>(deref(src).data()), deref(src).size(), offset);
  } else if constexpr (TypeT == kCharsType) {
    size_t size = 0;
 
    if constexpr (std::is_array_v<T>) {
      constexpr size_t kExtent = std::extent_v<T>;
      const auto* terminator = static_cast<const char*>(std::memchr(src, '\0', kExtent));
 
      if VUNLIKELY (!terminator) {
        VLOG_T("Serializer: Chars array is not null-terminated.");
        return false;
      }
 
      size = static_cast<size_t>(terminator - src);
    } else {
      if VUNLIKELY (!src) {
        VLOG_T("Serializer: Chars source is null.");
        return false;
      }
 
      size = std::strlen(src);
    }
 
    des = Bytes::deep_copy(reinterpret_cast<const uint8_t*>(src), size, offset);
  } else if constexpr (TypeT == kStreamType) {
    std::stringstream ss;
    ss << deref(src);
    const std::string str = ss.str();
    des = Bytes::deep_copy(reinterpret_cast<const uint8_t*>(str.data()), str.size(), offset);
  } else if constexpr (TypeT == kStandardType) {
    const auto* src_ptr = reinterpret_cast<const uint8_t*>(&deref(src));
    des = Bytes::deep_copy(src_ptr, sizeof(RealType), offset);
  } else if constexpr (TypeT == kStandardPtrType) {
    if VUNLIKELY (offset > 0) {
      VLOG_T("Serializer: Standard ptr does not support offset.");
      return false;
    }
 
    const auto* src_ptr = reinterpret_cast<const uint8_t*>(src);
    constexpr size_t kSize = sizeof(std::remove_pointer_t<T>);
 
    if (des.is_loaned() && des.size() >= kSize) {
      std::memcpy(des.data(), src_ptr, kSize);
    } else {
      des = Bytes::shallow_copy(src_ptr, kSize);
    }
  } else {
    static_assert(Traits::ExpectFalse<T>(), "Not support serialize.");
    return false;
  }
 
  return true;
}
 
template <typename T>
inline bool serialize(const T& src, Bytes& des) {
  constexpr auto kType = get_type_of<T>();
 
  return serialize<kType>(src, des, TransportType::kUnknown);
}
 
template <Type TypeT, typename T, typename LoanCallbackT>
inline bool serialize_to_transport(const T& src, Bytes& des, TransportType transport, bool use_loan,
                                   LoanCallbackT&& loan) {
#ifdef VLINK_HAS_FLATBUFFERS
  if constexpr (TypeT == kFlatBuilderType) {
    auto& mutable_src = const_cast<T&>(src);
    mutable_src.fbb_.Finish(mutable_src.Finish());
 
    const size_t size = mutable_src.fbb_.GetSize();
 
    if (use_loan) {
      des = std::forward<LoanCallbackT>(loan)(size);
 
      if VUNLIKELY (des.empty() || des.size() != size) {
        return false;
      }
 
      std::memcpy(des.data(), mutable_src.fbb_.GetBufferPointer(), size);
    } else {
      des = Bytes::shallow_copy(mutable_src.fbb_.GetBufferPointer(), size);
    }
 
    return true;
  } else {
#endif
    if (use_loan) {
      const size_t size = get_serialized_size<TypeT>(src);
 
      if (size == 0) {
        des = Bytes{};
      } else {
        des = std::forward<LoanCallbackT>(loan)(size);
 
        if VUNLIKELY (des.empty() || des.size() != size) {
          return false;
        }
      }
    }
 
    const bool had_loan = des.is_loaned();
    auto* loan_data = des.data();
    const size_t loan_size = des.size();
    const bool ret = serialize<TypeT>(src, des, transport);
 
    if VUNLIKELY (had_loan && (!des.is_loaned() || des.data() != loan_data || des.size() != loan_size)) {
      des = Bytes::loan_internal(loan_data, loan_size);
      return false;
    }
 
    return ret;
#ifdef VLINK_HAS_FLATBUFFERS
  }
#endif
}
 
template <Type TypeT, typename T>
inline bool deserialize(const Bytes& src, T& des, [[maybe_unused]] TransportType transport) {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
 
  if constexpr (TypeT == kBytesType) {
    des = src;
    return true;
  } else if constexpr (TypeT == kDynamicType) {
    try {
      using ReturnT = decltype(deref(des) << src);
 
      if constexpr (std::is_convertible_v<ReturnT, bool>) {
        if VUNLIKELY (!(deref(des) << src)) {
          VLOG_T("Serializer: Dynamic deserialize failed.");
          return false;
        }
      } else {
        deref(des) << src;
      }
    } catch (const std::exception& e) {                                  // LCOV_EXCL_LINE GCOVR_EXCL_LINE
      VLOG_T("Serializer: Dynamic deserialize threw: ", e.what(), ".");  // LCOV_EXCL_LINE GCOVR_EXCL_LINE
      return false;                                                      // LCOV_EXCL_LINE GCOVR_EXCL_LINE
    }
#ifdef VLINK_HAS_CDR
  } else if constexpr (TypeT == kCdrType) {
    if VUNLIKELY (!src.data() || src.size() < 4U || src.size() > std::numeric_limits<uint32_t>::max()) {
      VLOG_T("Serializer: FastBuffer payload has no CDR encapsulation.");
      return false;
    }
 
    try {
      eprosima::fastcdr::FastBuffer buffer(reinterpret_cast<char*>(const_cast<uint8_t*>(src.data())), src.size());
#if FASTCDR_VERSION_MAJOR >= 2
      eprosima::fastcdr::Cdr cdr(buffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
                                 eprosima::fastcdr::CdrVersion::DDS_CDR);
#else
      eprosima::fastcdr::Cdr cdr(buffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, eprosima::fastcdr::Cdr::DDS_CDR);
#endif
      cdr.read_encapsulation();
 
#ifdef VLINK_HAS_ROS2
      if constexpr (is_ros2_msg_type<RealType>()) {
        const auto* callbacks = get_ros2_msg_callbacks<RealType>();
 
        if VUNLIKELY (!callbacks || !callbacks->cdr_deserialize || !callbacks->cdr_deserialize(cdr, &deref(des))) {
          return false;
        }
      } else {
#endif
        if constexpr (VLINK_HAS_MEMBER(RealType, deserialize(cdr))) {
          deref(des).deserialize(cdr);
#if FASTCDR_VERSION_MAJOR >= 2
        } else {
          cdr >> deref(des);
#endif
        }
#ifdef VLINK_HAS_ROS2
      }
#endif
    } catch (const eprosima::fastcdr::exception::Exception& e) {
      VLOG_T("Serializer: FastBuffer deserialize failed: ", e.what(), ".");
      return false;
    } catch (const std::exception& e) {
      VLOG_T("Serializer: CDR deserialize failed: ", e.what(), ".");
      return false;
    }
#endif
#ifdef VLINK_HAS_PROTOBUF
  } else if constexpr (TypeT == kProtoType) {
    if (!src.empty()) {
      if VUNLIKELY (!deref(des).ParseFromArray(src.data(), src.size())) {
        VLOG_T("Serializer: Protobuf deserialize failed.");
        return false;
      }
    } else {
      deref(des).Clear();
    }
  } else if constexpr (TypeT == kProtoPtrType) {
    if (!src.empty()) {
      if VUNLIKELY (!des->ParseFromArray(src.data(), src.size())) {
        VLOG_T("Serializer: Protobuf ptr deserialize failed.");
        return false;
      }
    } else {
      des->Clear();
    }
#endif
#ifdef VLINK_HAS_FLATBUFFERS
  } else if constexpr (TypeT == kFlatTableType) {
    deref(des) = RealType{};
 
    if VLIKELY (!src.empty()) {
      flatbuffers::Verifier verifier(src.data(), src.size());
 
      if VUNLIKELY (!verifier.VerifyBuffer<typename RealType::TableType>(nullptr)) {
        VLOG_T("Serializer: Flatbuffers table deserialize failed.");
        return false;
      }
 
      auto target = flatbuffers::GetRoot<typename RealType::TableType>(src.data());
      target->UnPackTo(&deref(des));
    }
  } else if constexpr (TypeT == kFlatPtrType) {
    flatbuffers::Verifier verifier(src.data(), src.size());
 
    if VUNLIKELY (!verifier.VerifyBuffer<std::remove_pointer_t<T>>(nullptr)) {
      VLOG_T("Serializer: Flatbuffers ptr verify failed.");
      return false;
    }
 
    des = const_cast<T>(flatbuffers::GetRoot<std::remove_pointer_t<T>>(src.data()));
 
    if VUNLIKELY (!des) {
      VLOG_T("Serializer: Flatbuffers ptr deserialize failed.");
      return false;
    }
#endif
  } else if constexpr (TypeT == kCustomType) {
    try {
      using ReturnT = decltype(deref(des) << src);
 
      if constexpr (std::is_convertible_v<ReturnT, bool>) {
        if VUNLIKELY (!(deref(des) << src)) {
          VLOG_T("Serializer: Custom deserialize failed.");
          return false;
        }
      } else {
        deref(des) << src;
      }
    } catch (const std::exception& e) {
      VLOG_T("Serializer: Custom deserialize threw: ", e.what(), ".");
      return false;
    }
  } else if constexpr (TypeT == kStringType) {
    if VLIKELY (!src.empty()) {
      deref(des) = std::string(reinterpret_cast<const char*>(src.data()), src.size());
    } else {
      deref(des) = std::string();
    }
  } else if constexpr (TypeT == kCharsType) {
    (void)src;
    (void)des;
    VLOG_E("Serializer: Chars deserialization is not supported; use std::string.");
    return false;
  } else if constexpr (TypeT == kStreamType) {
    std::stringstream ss(std::string(reinterpret_cast<const char*>(src.data()), src.size()));
 
    ss >> deref(des);
 
    if VUNLIKELY (ss.fail()) {
      VLOG_T("Serializer: Stream deserialize failed.");
      return false;
    }
  } else if constexpr (TypeT == kStandardType) {
    if VLIKELY (!src.empty() && src.size() == sizeof(RealType)) {
      std::memcpy(&deref(des), src.data(), src.size());
    } else {
      VLOG_T("Serializer: Standard layout deserialize failed.");
      return false;
    }
  } else if constexpr (TypeT == kStandardPtrType) {
    if VLIKELY (!src.empty() && src.size() == sizeof(std::remove_pointer_t<T>)) {
      des = reinterpret_cast<T>(const_cast<uint8_t*>(src.data()));
    } else {
      VLOG_T("Serializer: Standard ptr layout deserialize failed.");
      return false;
    }
  } else {
    static_assert(Traits::ExpectFalse<T>(), "Not support deserialize.");
    return false;
  }
 
  return true;
}
 
template <typename T>
inline bool deserialize(const Bytes& src, T& des) {
  constexpr auto kType = get_type_of<T>();
  return deserialize<kType>(src, des, TransportType::kUnknown);
}
 
template <typename SrcT, typename DesT>
inline bool convert(const SrcT& src, DesT& des) {
  static_assert(is_bytes_type<SrcT>() || is_bytes_type<DesT>(), "SrcT or DesT must be Bytes.");
 
  if constexpr (is_bytes_type<SrcT>() && is_bytes_type<DesT>()) {
    des.shallow_copy(src);
    return true;
  } else if constexpr (is_bytes_type<DesT>()) {
    return serialize(src, des);
  } else {
    return deserialize(src, des);
  }
}
 
template <typename T>
inline constexpr auto& deref(const T& t) noexcept {
  if constexpr (Traits::IsSharedPtr<T>()) {
    return *const_cast<T&>(t).get();
  } else {
    return const_cast<T&>(t);
  }
}
 
template <typename T>
inline constexpr bool is_bytes_type() noexcept {
  return std::is_same_v<T, Bytes>;
}
 
template <typename T>
inline constexpr bool is_dynamic_type() noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  return VLINK_HAS_MEMBER(RealType, is_vlink_dynamic_data());
}
 
template <typename T>
inline constexpr bool is_cdr_type() noexcept {
#ifdef VLINK_HAS_CDR
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
 
#ifdef VLINK_HAS_ROS2
  if constexpr (is_ros2_msg_type<RealType>()) {
    return true;
  }
#endif
 
  return (VLINK_HAS_MEMBER(RealType, serialize(std::declval<eprosima::fastcdr::Cdr&>())) &&
          VLINK_HAS_MEMBER(RealType, deserialize(std::declval<eprosima::fastcdr::Cdr&>()))) ||
         Helpers::contains_substring(NameDetector::get<RealType>(), VLINK_DDS_IDL_PREFIX);
#else
  return false;
#endif
}
 
template <typename T>
inline constexpr bool is_proto_type() noexcept {
#ifdef VLINK_HAS_PROTOBUF
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  return VLINK_HAS_MEMBER(RealType, SerializeToArray(0, 0)) && VLINK_HAS_MEMBER(RealType, ParseFromArray(0, 0));
#else
  return false;
#endif
}
 
template <typename T>
inline constexpr bool is_proto_ptr_type() noexcept {
#ifdef VLINK_HAS_PROTOBUF
  return std::is_pointer_v<T> && VLINK_HAS_MEMBER(std::remove_pointer_t<T>, SerializeToArray(0, 0)) &&
         VLINK_HAS_MEMBER(std::remove_pointer_t<T>, ParseFromArray(0, 0));
#else
  return false;
#endif
}
 
template <typename T>
inline constexpr bool is_flat_table_type() noexcept {
#ifdef VLINK_HAS_FLATBUFFERS
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  return std::is_base_of_v<flatbuffers::NativeTable, RealType>;
#else
  return false;
#endif
}
 
template <typename T>
inline constexpr bool is_flat_builder_type() noexcept {
#ifdef VLINK_HAS_FLATBUFFERS
  return VLINK_HAS_MEMBER(T, fbb_) && VLINK_HAS_MEMBER(T, Finish());
#else
  return false;
#endif
}
 
template <typename T>
inline constexpr bool is_flat_ptr_type() noexcept {
#ifdef VLINK_HAS_FLATBUFFERS
  return std::is_pointer_v<T> && std::is_base_of_v<flatbuffers::Table, std::remove_pointer_t<T>>;
#else
  return false;
#endif
}
 
template <typename T>
inline constexpr bool is_custom_type() noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  return Traits::Operatorable<std::decay_t<RealType>, Bytes>();
}
 
template <typename T>
inline constexpr bool is_string_type() noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  return std::is_same_v<RealType, std::string>;
}
 
template <typename T>
inline constexpr bool is_chars_type() noexcept {
  using DecayedType = std::decay_t<T>;
  using CharType = std::remove_pointer_t<DecayedType>;
 
  return std::is_pointer_v<DecayedType> && std::is_same_v<std::remove_cv_t<CharType>, char> &&
         !std::is_volatile_v<CharType>;
}
 
template <typename T>
inline constexpr bool is_stream_type() noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  return !std::is_pointer_v<RealType> && Traits::Operatorable<std::stringstream, std::decay_t<RealType>>();
}
 
template <typename T>
inline constexpr bool is_standard_type() noexcept {
  using RealType = typename Traits::RemoveSharedPtr<T>::Type;
  return !std::is_pointer_v<RealType> && std::is_trivial_v<RealType> && std::is_standard_layout_v<RealType>;
}
 
template <typename T>
inline constexpr bool is_standard_ptr_type() noexcept {
  return std::is_pointer_v<T> && std::is_trivial_v<std::remove_pointer_t<T>> &&
         std::is_standard_layout_v<std::remove_pointer_t<T>>;
}
 
}  // namespace Serializer
 
}  // namespace vlink