58 #include <type_traits>
59 #include <unordered_map>
64 #include "../base/bytes.h"
65 #include "../base/macros.h"
66 #include "../base/traits.h"
74 namespace SomeipSerializer {
83 static constexpr
size_t kMaxPayloadSize = std::numeric_limits<uint32_t>::max() - 8U;
135 [[nodiscard]]
bool is_size_only() const noexcept;
143 [[nodiscard]]
Writer size_only() const noexcept;
157 [[nodiscard]]
bool append(const uint8_t* data,
size_t size) noexcept;
166 [[nodiscard]]
bool append_unsigned(uint64_t value,
size_t width) noexcept;
180 [[nodiscard]]
bool append_unsigned(uint64_t value,
size_t width,
Endian endian) noexcept;
190 [[nodiscard]]
bool begin_length_delimited(
size_t& length_position,
size_t& data_position,
191 size_t width = sizeof(uint32_t)) noexcept;
205 [[nodiscard]]
bool end_length_delimited(
size_t length_position,
size_t data_position,
206 size_t width = sizeof(uint32_t)) noexcept;
213 [[nodiscard]]
bool align() noexcept;
216 uint8_t* data_{
nullptr};
219 size_t alignment_{1U};
262 [[nodiscard]]
size_t size() const noexcept;
269 [[nodiscard]] const uint8_t* current_data() const noexcept;
283 [[nodiscard]]
bool read(uint8_t* data,
size_t size,
size_t end) noexcept;
292 [[nodiscard]]
bool skip(
size_t size,
size_t end) noexcept;
302 [[nodiscard]]
bool read_unsigned(uint64_t& value,
size_t width,
size_t end) noexcept;
317 [[nodiscard]]
bool read_unsigned(uint64_t& value,
size_t width,
Endian endian,
size_t end) noexcept;
331 [[nodiscard]]
bool begin_length_delimited(
size_t end,
size_t& value_end,
size_t width = sizeof(uint32_t)) noexcept;
339 [[nodiscard]]
bool align(
size_t end) noexcept;
342 const uint8_t* data_{
nullptr};
345 size_t alignment_{1U};
362 template <
typename T>
363 inline bool write_value(Writer& writer,
const T& value) noexcept;
383 template <size_t MaxT = std::numeric_limits<size_t>::max(),
typename T,
typename AllocatorT,
size_t... InnerLenT>
384 inline bool write_value(Writer& writer,
const std::vector<T, AllocatorT>& value,
size_t len =
sizeof(uint32_t),
385 std::index_sequence<InnerLenT...> = {}) noexcept;
398 template <
typename T,
size_t SizeT,
size_t... InnerLenT>
399 inline bool write_value(Writer& writer,
const std::array<T, SizeT>& value,
size_t len =
sizeof(uint32_t),
400 std::index_sequence<InnerLenT...> = {}) noexcept;
419 template <
typename KeyT,
typename ValueT,
typename CompareT,
typename AllocatorT>
420 inline bool write_value(Writer& writer,
const std::map<KeyT, ValueT, CompareT, AllocatorT>& value,
421 size_t len =
sizeof(uint32_t)) noexcept;
423 template <
typename KeyT,
typename ValueT,
typename HashT,
typename EqualT,
typename AllocatorT>
424 inline bool write_value(Writer& writer,
const std::unordered_map<KeyT, ValueT, HashT, EqualT, AllocatorT>& value,
425 size_t len =
sizeof(uint32_t)) noexcept;
447 template <
typename... AlternativeT>
448 inline bool write_value(Writer& writer,
const std::variant<AlternativeT...>& value,
size_t len =
sizeof(uint32_t),
449 size_t type_width =
sizeof(uint32_t)) noexcept;
464 template <
typename T>
465 inline bool read_value(Reader& reader, T& value,
size_t end) noexcept;
485 template <size_t MaxT = std::numeric_limits<size_t>::max(),
typename T,
typename AllocatorT,
size_t... InnerLenT>
486 inline bool read_value(Reader& reader, std::vector<T, AllocatorT>& value,
size_t end,
size_t len =
sizeof(uint32_t),
487 std::index_sequence<InnerLenT...> = {}) noexcept;
506 template <
typename T,
size_t SizeT,
size_t... InnerLenT>
507 inline bool read_value(Reader& reader, std::array<T, SizeT>& value,
size_t end,
size_t len =
sizeof(uint32_t),
508 std::index_sequence<InnerLenT...> = {}) noexcept;
526 template <
typename KeyT,
typename ValueT,
typename CompareT,
typename AllocatorT>
527 inline bool read_value(Reader& reader, std::map<KeyT, ValueT, CompareT, AllocatorT>& value,
size_t end,
528 size_t len =
sizeof(uint32_t)) noexcept;
530 template <
typename KeyT,
typename ValueT,
typename HashT,
typename EqualT,
typename AllocatorT>
531 inline bool read_value(Reader& reader, std::unordered_map<KeyT, ValueT, HashT, EqualT, AllocatorT>& value,
size_t end,
532 size_t len =
sizeof(uint32_t)) noexcept;
555 template <
typename... AlternativeT>
556 inline bool read_value(Reader& reader, std::variant<AlternativeT...>& value,
size_t end,
size_t len =
sizeof(uint32_t),
557 size_t type_width =
sizeof(uint32_t)) noexcept;
570 template <
typename T>
587 template <
typename T>
588 inline bool serialize(
const T& src, Bytes& des) noexcept;
605 template <
typename T>
606 inline bool serialize(
const T& src, Bytes& des, uint8_t offset) noexcept;
623 template <
typename T>
624 inline bool deserialize(
const Bytes& src, T& des) noexcept;
632 template <
typename T>
653 size_t maximum = std::numeric_limits<size_t>::max()) noexcept;
655 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
658 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
660 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
662 Endian encoding,
size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
675 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
677 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
680 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
682 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
684 Endian encoding,
size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
686 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
688 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
690 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
693 size_t& data_end) noexcept;
695 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
697 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
699 size_t maximum = std::numeric_limits<
size_t>::max()) noexcept;
702 size_t& length_position,
size_t& content_position) noexcept;
704 size_t& body_end) noexcept;
706 size_t& data_position) noexcept;
713 template <typename T>
716 template <typename T>
719 template <typename T>
722 constexpr
size_t kAlignment = T::vlink_someip_alignment();
724 static_assert(kAlignment == 1U || kAlignment == 2U || kAlignment == 4U || kAlignment == 8U || kAlignment == 16U ||
726 "SOME/IP alignment must be 1, 2, 4, 8, 16, or 32 bytes.");
733 template <
typename T>
736 return T::vlink_someip_endian();
742 template <
typename T>
745 constexpr
size_t kLength = T::vlink_someip_struct_length();
747 static_assert(kLength == 0U || kLength == 1U || kLength == 2U || kLength == 4U,
748 "SOME/IP structure length field width must be 0, 1, 2, or 4 bytes.");
755 template <
typename T>
756 [[nodiscard]] constexpr
bool is_map(
const T*) noexcept {
760 template <
typename KeyT,
typename ValueT,
typename CompareT,
typename AllocatorT>
761 [[nodiscard]] constexpr
bool is_map(
const std::map<KeyT, ValueT, CompareT, AllocatorT>*) noexcept {
765 template <
typename KeyT,
typename ValueT,
typename HashT,
typename EqualT,
typename AllocatorT>
766 [[nodiscard]] constexpr
bool is_map(
const std::unordered_map<KeyT, ValueT, HashT, EqualT, AllocatorT>*) noexcept {
770 template <
typename T>
771 [[nodiscard]] constexpr
bool is_vector(
const T*) noexcept {
775 template <
typename T,
typename AllocatorT>
776 [[nodiscard]] constexpr
bool is_vector(
const std::vector<T, AllocatorT>*) noexcept {
780 template <
typename T>
785 template <
typename... AlternativeT>
786 [[nodiscard]] constexpr
bool is_variant(
const std::variant<AlternativeT...>*) noexcept {
790 template <
typename T>
795 template <
typename T>
796 [[nodiscard]] constexpr
bool is_optional(
const std::optional<T>*) noexcept {
800 template <
typename T>
802 using ValueType = std::remove_cv_t<T>;
804 return std::is_same_v<ValueType, std::string> || std::is_same_v<ValueType, std::u16string> ||
805 std::is_same_v<ValueType, Bytes> ||
is_vector(
static_cast<const ValueType*
>(
nullptr));
808 template <
typename T>
813 static constexpr uint8_t kComplexWireType = 0xFFU;
815 template <
typename T>
817 using ValueType = std::remove_cv_t<T>;
819 if constexpr (std::is_enum_v<ValueType>) {
820 return get_fixed_wire_type<std::underlying_type_t<ValueType>>();
821 }
else if constexpr (std::is_arithmetic_v<ValueType>) {
822 if constexpr (
sizeof(ValueType) ==
sizeof(uint8_t)) {
824 }
else if constexpr (
sizeof(ValueType) ==
sizeof(uint16_t)) {
826 }
else if constexpr (
sizeof(ValueType) ==
sizeof(uint32_t)) {
832 return kComplexWireType;
836 template <
typename... AlternativeT>
838 constexpr
size_t kNullCount = (
static_cast<size_t>(std::is_same_v<AlternativeT, std::monostate>) + ... + 0U);
840 static_assert(kNullCount <= 1U,
"SOME/IP unions accept at most one std::monostate alternative.");
842 kNullCount == 0U || std::is_same_v<std::tuple_element_t<0U, std::tuple<AlternativeT...>>, std::monostate>,
843 "SOME/IP union std::monostate must be the first alternative for selector zero.");
844 static_assert(kNullCount == 0U ||
sizeof...(AlternativeT) > 1U,
845 "SOME/IP unions require at least one non-null alternative.");
850 template <
typename FirstT,
typename... AlternativeT>
852 return (std::is_arithmetic_v<FirstT> || std::is_enum_v<FirstT>) &&
853 ((std::is_arithmetic_v<AlternativeT> || std::is_enum_v<AlternativeT>) && ...) &&
854 ((
sizeof(FirstT) ==
sizeof(AlternativeT)) && ...);
857 template <
typename... AlternativeT>
859 return std::is_same_v<std::tuple_element_t<0U, std::tuple<AlternativeT...>>, std::monostate>;
862 template <
size_t LenT,
typename T>
864 return LenT > 0U && (std::is_same_v<T, std::string> || std::is_same_v<T, std::u16string> ||
865 std::is_same_v<T, Bytes> ||
is_map(
static_cast<const T*
>(
nullptr)));
868 template <
size_t LenT,
typename T,
typename AllocatorT>
873 template <
size_t LenT,
typename T,
size_t SizeT>
878 template <size_t LenT, typename T, size_t MaxT = std::numeric_limits<size_t>::max()>
880 static_assert(MaxT == std::numeric_limits<size_t>::max() ||
supports_maximum(
static_cast<const T*
>(
nullptr)),
881 "SOME/IP maximum applies only to string, u16string, Bytes, and vector fields.");
886 template <
typename T,
size_t LenT,
size_t... InnerLenT>
890 static_assert((LenT == 0U || LenT == 1U || LenT == 2U || LenT == 4U) &&
891 ((InnerLenT == 0U || InnerLenT == 1U || InnerLenT == 2U || InnerLenT == 4U) && ...),
892 "SOME/IP array length field width must be 0, 1, 2, or 4 bytes.");
893 static_assert(!std::is_same_v<ValueType, std::string> && !std::is_same_v<ValueType, std::u16string> &&
894 !std::is_same_v<ValueType, Bytes> && !
is_map(
static_cast<const ValueType*
>(
nullptr)) &&
895 supports_length_field<LenT>(
static_cast<const ValueType*
>(
nullptr)),
896 "VLINK_SOMEIP_ARRAY_LENGTH supports vector widths 1/2/4 and array widths 0/1/2/4.");
901 template <size_t LenT, Endian EncodingT, typename T, size_t MaxT = std::numeric_limits<size_t>::max()>
903 static_assert(LenT == 1U || LenT == 2U || LenT == 4U,
"SOME/IP UTF-16 length field width must be 1, 2, or 4 bytes.");
904 static_assert(std::is_same_v<std::remove_cv_t<T>, std::u16string>,
905 "VLINK_SOMEIP_UTF16 requires a std::u16string field.");
910 template <size_t SizeT, size_t LenT, Endian EncodingT, typename T, size_t MaxT = std::numeric_limits<size_t>::max()>
914 static_assert(LenT == 0U || LenT == 1U || LenT == 2U || LenT == 4U,
915 "SOME/IP fixed string length field width must be 0, 1, 2, or 4 bytes.");
916 static_assert(std::is_same_v<ValueType, std::string> || std::is_same_v<ValueType, std::u16string>,
917 "VLINK_SOMEIP_FIXED_STRING requires a std::string or std::u16string field.");
918 static_assert(SizeT >= 4U && (std::is_same_v<ValueType, std::string> || SizeT % 2U == 0U),
919 "SOME/IP fixed strings must hold a BOM and terminator; UTF-16 sizes must be even.");
920 static_assert(LenT == 0U || SizeT <= ((uint64_t{1U} << (LenT * 8U)) - 1U),
921 "SOME/IP fixed string size does not fit its length field.");
926 template <
size_t LenT,
size_t TypeT,
typename T>
928 static_assert(LenT == 0U || LenT == 1U || LenT == 2U || LenT == 4U,
929 "SOME/IP union length field width must be 0, 1, 2, or 4 bytes.");
930 static_assert(TypeT == 1U || TypeT == 2U || TypeT == 4U,
931 "SOME/IP union type selector width must be 1, 2, or 4 bytes.");
932 static_assert(
is_variant(
static_cast<const std::remove_cv_t<T>*
>(
nullptr)),
933 "VLINK_SOMEIP_UNION requires a std::variant field.");
935 "SOME/IP unions without a length field require equal-size arithmetic or enum alternatives.");
940 template <uint16_t DataIdT, size_t LenT, bool DynamicT, typename T, size_t MaxT = std::numeric_limits<size_t>::max()>
942 static constexpr uint16_t kDataId = DataIdT;
943 static constexpr
size_t kLengthWidth = LenT;
945 static_assert(DataIdT <= 0x0FFFU,
"SOME/IP TLV data IDs must fit the 12-bit tag field.");
946 static_assert(LenT == 1U || LenT == 2U || LenT == 4U,
"SOME/IP TLV length field width must be 1, 2, or 4 bytes.");
947 static_assert(MaxT == std::numeric_limits<size_t>::max() ||
supports_maximum(
static_cast<const T*
>(
nullptr)),
948 "SOME/IP maximum applies only to string, u16string, Bytes, and vector fields.");
953 template <uint16_t DataIdT,
size_t LenT,
bool DynamicT,
size_t SizeT,
Endian EncodingT,
typename T,
954 size_t MaxT = std::numeric_limits<size_t>::max()>
958 std::is_same_v<ValueType, std::u16string> || std::is_same_v<ValueType, std::optional<std::u16string>>;
963 static_assert(DataIdT <= 0x0FFFU,
"SOME/IP TLV data IDs must fit the 12-bit tag field.");
964 static_assert(LenT == 1U || LenT == 2U || LenT == 4U,
"SOME/IP TLV length field width must be 1, 2, or 4 bytes.");
965 static_assert(std::is_same_v<ValueType, std::string> || std::is_same_v<ValueType, std::u16string> ||
966 std::is_same_v<
ValueType, std::optional<std::string>> ||
967 std::is_same_v<
ValueType, std::optional<std::u16string>>,
968 "VLINK_SOMEIP_TLV_FIXED_STRING requires a string or optional string field.");
969 static_assert(SizeT >= 4U && (!
kUtf16 || SizeT % 2U == 0U),
970 "SOME/IP fixed strings must hold a BOM and terminator; UTF-16 sizes must be even.");
971 static_assert(DynamicT || SizeT <= ((uint64_t{1U} << (LenT * 8U)) - 1U),
972 "SOME/IP static TLV fixed string size does not fit its length field.");
977 template <uint16_t DataIdT,
size_t LenT,
bool DynamicT,
typename T,
size_t... InnerLenT>
982 static_assert(DataIdT <= 0x0FFFU,
"SOME/IP TLV data IDs must fit the 12-bit tag field.");
983 static_assert(LenT == 1U || LenT == 2U || LenT == 4U,
"SOME/IP TLV length field width must be 1, 2, or 4 bytes.");
984 static_assert(((InnerLenT == LenT) && ...),
"SOME/IP TLV array dimensions must use the structure length width.");
989 template <
typename... FieldT>
990 [[nodiscard]]
inline auto make_fields(FieldT&&... field) noexcept {
991 return std::tuple<FieldT...>(std::forward<FieldT>(field)...);
994 template <size_t LenT, size_t MaxT = std::numeric_limits<size_t>::max(),
typename T>
996 using ValueType = std::remove_cv_t<T>;
998 static_assert(LenT == 0U || LenT == 1U || LenT == 2U || LenT == 4U,
999 "SOME/IP length field width must be 0, 1, 2, or 4 bytes.");
1000 static_assert(supports_length_field<LenT>(
static_cast<const ValueType*
>(
nullptr)),
1001 "VLINK_SOMEIP_LENGTH supports string, u16string, Bytes, vector, and map widths 1/2/4 or array "
1007 template <
size_t LenT,
size_t... InnerLenT,
typename T>
1012 template <size_t LenT, Endian EncodingT, size_t MaxT = std::numeric_limits<size_t>::max(),
typename T>
1017 template <size_t SizeT, size_t LenT, Endian EncodingT = Endian::kBig, size_t MaxT = std::numeric_limits<size_t>::max(),
1023 template <
size_t LenT,
size_t TypeT,
typename T>
1028 template <uint16_t DataIdT,
size_t LenT =
sizeof(uint32_t),
bool DynamicT =
true,
1029 size_t MaxT = std::numeric_limits<size_t>::max(),
typename T>
1034 template <uint16_t DataIdT,
size_t LenT,
bool DynamicT,
size_t SizeT,
Endian EncodingT,
1035 size_t MaxT = std::numeric_limits<size_t>::max(),
typename T>
1040 template <uint16_t DataIdT,
size_t LenT,
bool DynamicT,
size_t... InnerLenT,
typename T>
1042 return TlvArrayField<DataIdT, LenT, DynamicT, T, InnerLenT...>{value};
1045 template <
typename T>
1050 template <u
int16_t DataIdT,
size_t LenT,
bool DynamicT,
typename T,
size_t MaxT>
1055 template <u
int16_t DataIdT,
size_t LenT,
bool DynamicT,
size_t SizeT, Endian EncodingT,
typename T,
size_t MaxT>
1061 template <uint16_t DataIdT,
size_t LenT,
bool DynamicT,
typename T,
size_t... InnerLenT>
1066 template <
typename TupleT,
size_t... IndexT>
1069 static_cast<const std::remove_reference_t<std::tuple_element_t<IndexT, TupleT>
>*>(
nullptr))) +
1073 template <
typename TupleT,
size_t... IndexT>
1075 constexpr
size_t kFieldCount =
sizeof...(IndexT);
1076 const uint16_t ids[kFieldCount] = {std::remove_reference_t<std::tuple_element_t<IndexT, TupleT>>::kDataId...};
1078 for (
size_t left = 0U; left < kFieldCount; ++left) {
1079 for (
size_t right = left + 1U; right < kFieldCount; ++right) {
1080 if (ids[left] == ids[right]) {
1089 template <
size_t LenT,
typename TupleT,
size_t... IndexT>
1091 return ((std::remove_reference_t<std::tuple_element_t<IndexT, TupleT>>::kLengthWidth == LenT) && ...);
1094 template <
typename TupleT,
size_t... IndexT>
1096 return (
is_variable_size<std::remove_reference_t<std::tuple_element_t<IndexT, TupleT>>>() || ...);
1099 template <
typename T,
typename AllocatorT>
1104 template <
typename T,
size_t SizeT>
1106 return is_variable_size<T>();
1109 template <
size_t LenT,
typename T,
size_t MaxT>
1111 return is_variable_size<T>();
1114 template <
typename T,
size_t LenT,
size_t... InnerLenT>
1116 return is_variable_size<T>();
1119 template <
typename KeyT,
typename ValueT,
typename CompareT,
typename AllocatorT>
1120 [[nodiscard]] constexpr
bool is_variable_size(
const std::map<KeyT, ValueT, CompareT, AllocatorT>*) noexcept {
1124 template <
typename KeyT,
typename ValueT,
typename HashT,
typename EqualT,
typename AllocatorT>
1126 const std::unordered_map<KeyT, ValueT, HashT, EqualT, AllocatorT>*) noexcept {
1130 template <
typename... AlternativeT>
1135 template <
size_t LenT, Endian EncodingT,
typename T,
size_t MaxT>
1140 template <
size_t SizeT,
size_t LenT, Endian EncodingT,
typename T,
size_t MaxT>
1145 template <
size_t LenT,
size_t TypeT,
typename T>
1150 template <u
int16_t DataIdT,
size_t LenT,
bool DynamicT,
typename T,
size_t MaxT>
1155 template <u
int16_t DataIdT,
size_t LenT,
bool DynamicT,
size_t SizeT, Endian EncodingT,
typename T,
size_t MaxT>
1161 template <
typename T>
1163 if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, std::u16string> || std::is_same_v<T, Bytes>) {
1166 using FieldsType = decltype(std::declval<T&>().get_vlink_someip_fields());
1168 return fields_are_variable<FieldsType>(std::make_index_sequence<std::tuple_size_v<FieldsType>>{});
1174 template <
typename T>
1176 using ValueType = std::remove_cv_t<std::remove_reference_t<T>>;
1181 template <
typename T>
1183 using ValueType = std::remove_cv_t<T>;
1185 if constexpr (std::is_enum_v<ValueType>) {
1186 using UnderlyingType = std::underlying_type_t<ValueType>;
1188 static_assert(std::is_unsigned_v<UnderlyingType> && !std::is_same_v<UnderlyingType, bool>,
1189 "SOME/IP enums must use uint8_t, uint16_t, uint32_t, or uint64_t storage.");
1191 }
else if constexpr (std::is_arithmetic_v<ValueType> || std::is_same_v<ValueType, std::string> ||
1192 std::is_same_v<ValueType, Bytes>) {
1194 }
else if constexpr (std::is_same_v<ValueType, std::u16string>) {
1196 }
else if constexpr (
VLINK_HAS_MEMBER(ValueType, is_vlink_someip_type())) {
1197 static constexpr
size_t kStructLength = get_struct_length<ValueType>();
1200 static_assert(noexcept(value.check_available()),
"SOME/IP check_available() must be noexcept.");
1201 if VUNLIKELY (!value.check_available()) {
1208 size_t length_position = 0U;
1209 size_t data_position = 0U;
1211 if constexpr (kStructLength > 0U) {
1221 return kStructLength == 0U || writer.
end_length_delimited(length_position, data_position, kStructLength);
1229 template <
size_t MaxT,
typename T,
typename AllocatorT,
size_t... InnerLenT>
1231 std::index_sequence<InnerLenT...>) noexcept {
1236 size_t length_position = 0U;
1237 size_t data_position = 0U;
1244 template <
typename T,
size_t SizeT,
size_t... InnerLenT>
1246 std::index_sequence<InnerLenT...>) noexcept {
1247 size_t length_position = 0U;
1248 size_t data_position = 0U;
1261 template <
typename KeyT,
typename ValueT,
typename CompareT,
typename AllocatorT>
1263 size_t len) noexcept {
1264 size_t length_position = 0U;
1265 size_t data_position = 0U;
1271 template <
typename KeyT,
typename ValueT,
typename HashT,
typename EqualT,
typename AllocatorT>
1272 inline bool write_value(
Writer& writer,
const std::unordered_map<KeyT, ValueT, HashT, EqualT, AllocatorT>& value,
1273 size_t len) noexcept {
1274 size_t length_position = 0U;
1275 size_t data_position = 0U;
1281 template <
typename... AlternativeT>
1283 size_t type_width) noexcept {
1284 static_assert(validate_union_alternatives<AlternativeT...>(),
"SOME/IP union alternatives are invalid.");
1286 if VUNLIKELY (value.valueless_by_exception()) {
1291 const uint64_t selector = value.index() + (kHasNull ? 0U : 1U);
1293 size_t length_position = 0U;
1294 size_t content_position = 0U;
1306 if constexpr (kHasNull) {
1307 if (value.index() == 0U) {
1315 template <
typename T>
1317 using ValueType = std::remove_cv_t<T>;
1319 if constexpr (std::is_enum_v<ValueType>) {
1320 using UnderlyingType = std::underlying_type_t<ValueType>;
1322 static_assert(std::is_unsigned_v<UnderlyingType> && !std::is_same_v<UnderlyingType, bool>,
1323 "SOME/IP enums must use uint8_t, uint16_t, uint32_t, or uint64_t storage.");
1324 UnderlyingType raw = 0;
1330 value =
static_cast<T
>(raw);
1333 }
else if constexpr (std::is_arithmetic_v<ValueType> || std::is_same_v<ValueType, std::string> ||
1334 std::is_same_v<ValueType, Bytes>) {
1336 }
else if constexpr (std::is_same_v<ValueType, std::u16string>) {
1338 }
else if constexpr (
VLINK_HAS_MEMBER(ValueType, is_vlink_someip_type())) {
1339 static constexpr
size_t kStructLength = get_struct_length<ValueType>();
1341 size_t struct_end = end;
1343 if constexpr (kStructLength > 0U) {
1344 if VUNLIKELY (!reader.begin_length_delimited(end, struct_end, kStructLength)) {
1353 return kStructLength == 0U || reader.skip(struct_end - reader.position(), struct_end);
1361 template <
size_t MaxT,
typename T,
typename AllocatorT,
size_t... InnerLenT>
1362 inline bool read_value(
Reader& reader, std::vector<T, AllocatorT>& value,
size_t end,
size_t len,
1363 std::index_sequence<InnerLenT...>) noexcept {
1364 size_t array_end = 0U;
1366 return reader.begin_length_delimited(end, array_end, len) &&
1367 read_value_body<MaxT>(reader, value, array_end, std::index_sequence<InnerLenT...>{});
1370 template <
typename T,
size_t SizeT,
size_t... InnerLenT>
1372 std::index_sequence<InnerLenT...>) noexcept {
1373 size_t array_end = end;
1375 if VUNLIKELY (len > 0U && !reader.begin_length_delimited(end, array_end, len)) {
1383 return len == 0U || reader.skip(array_end - reader.position(), array_end);
1386 template <
typename KeyT,
typename ValueT,
typename CompareT,
typename AllocatorT>
1387 inline bool read_value(
Reader& reader, std::map<KeyT, ValueT, CompareT, AllocatorT>& value,
size_t end,
1388 size_t len) noexcept {
1389 size_t map_end = 0U;
1391 return reader.begin_length_delimited(end, map_end, len) &&
read_map_entries(reader, value, map_end);
1394 template <
typename KeyT,
typename ValueT,
typename HashT,
typename EqualT,
typename AllocatorT>
1395 inline bool read_value(
Reader& reader, std::unordered_map<KeyT, ValueT, HashT, EqualT, AllocatorT>& value,
size_t end,
1396 size_t len) noexcept {
1397 size_t map_end = 0U;
1399 return reader.begin_length_delimited(end, map_end, len) &&
read_map_entries(reader, value, map_end);
1402 template <
typename... AlternativeT>
1403 inline bool read_value(
Reader& reader, std::variant<AlternativeT...>& value,
size_t end,
size_t len,
1404 size_t type_width) noexcept {
1405 static_assert(validate_union_alternatives<AlternativeT...>(),
"SOME/IP union alternatives are invalid.");
1407 uint64_t selector = 0U;
1408 size_t data_end = 0U;
1411 return reader.read_unsigned(selector, type_width,
Endian::kBig, end) &&
1412 read_union_alternative(reader, value, selector, end, std::make_index_sequence<
sizeof...(AlternativeT)>{});
1416 (selector == 0U && reader.position() != data_end) ||
1418 std::make_index_sequence<
sizeof...(AlternativeT)>{})) {
1422 return reader.skip(data_end - reader.position(), data_end);
1425 template <
typename T>
1427 Writer writer(
nullptr, std::numeric_limits<size_t>::max(), get_alignment<T>(), get_endian<T>());
1432 template <
typename T>
1437 template <
typename T>
1439 if (des.is_loaned()) {
1444 Writer writer(des.data(), des.size(), get_alignment<T>(), get_endian<T>());
1449 Writer size_writer(
nullptr, std::numeric_limits<size_t>::max(), get_alignment<T>(), get_endian<T>());
1455 Writer writer(des.data(), des.size(), get_alignment<T>(), get_endian<T>());
1460 template <
typename T>
1462 if VUNLIKELY (src.size() > kMaxPayloadSize) {
1466 Reader reader(src.data(), src.size(), get_alignment<T>(), get_endian<T>());
1471 template <
size_t LenT,
typename T,
size_t MaxT>
1473 using ValueType = std::remove_cv_t<T>;
1475 if constexpr (std::is_same_v<ValueType, std::string> || std::is_same_v<ValueType, Bytes>) {
1477 }
else if constexpr (std::is_same_v<ValueType, std::u16string>) {
1479 }
else if constexpr (
is_vector(
static_cast<const ValueType*
>(
nullptr))) {
1480 return read_value<MaxT>(reader, field.value, end, LenT, std::index_sequence<>{});
1481 }
else if constexpr (
is_map(
static_cast<const ValueType*
>(
nullptr))) {
1482 return read_value(reader, field.value, end, LenT);
1484 return read_value(reader, field.value, end, LenT, std::index_sequence<>{});
1488 template <
typename T,
size_t LenT,
size_t... InnerLenT>
1490 return read_value(reader, field.value, end, LenT, std::index_sequence<InnerLenT...>{});
1493 template <
size_t LenT, Endian EncodingT,
typename T,
size_t MaxT>
1498 template <
size_t SizeT,
size_t LenT, Endian EncodingT,
typename T,
size_t MaxT>
1500 if constexpr (std::is_same_v<std::remove_cv_t<T>, std::string>) {
1507 template <
size_t SizeT,
size_t LenT, Endian EncodingT,
typename T,
size_t MaxT>
1509 size_t end) noexcept {
1510 if VUNLIKELY (reader.position() > end || end - reader.position() > SizeT) {
1514 const size_t size = end - reader.position();
1516 if constexpr (std::is_same_v<std::remove_cv_t<T>, std::string>) {
1523 template <
size_t LenT,
size_t TypeT,
typename T>
1525 return read_value(reader, field.value, end, LenT, TypeT);
1528 template <
typename TupleT,
size_t... IndexT>
1529 inline bool read_fields(
Reader& reader, TupleT& fields,
size_t end, std::index_sequence<IndexT...>) noexcept {
1530 static constexpr
size_t kFieldCount = std::tuple_size_v<TupleT>;
1532 return ([&reader, &fields, end]() {
1537 using FieldType = std::remove_reference_t<std::tuple_element_t<IndexT, TupleT>>;
1539 return IndexT + 1U == kFieldCount || !is_variable_size<FieldType>() || reader.align(end);
1543 template <size_t MaxT = std::numeric_limits<size_t>::max(),
typename T,
typename AllocatorT,
size_t... InnerLenT>
1545 std::index_sequence<InnerLenT...> = {}) noexcept {
1546 if constexpr (std::is_arithmetic_v<T> || std::is_enum_v<T>) {
1547 static constexpr
size_t kElementSize =
sizeof(T);
1549 const size_t byte_length = end - reader.
position();
1550 const size_t element_count = byte_length / kElementSize;
1552 if VUNLIKELY (byte_length % kElementSize != 0U && element_count < MaxT) {
1556 value.reserve(element_count < MaxT ? element_count : MaxT);
1561 while (reader.
position() < end && index < MaxT) {
1562 const size_t element_position = reader.
position();
1564 if constexpr (
sizeof...(InnerLenT) > 0U) {
1565 if (index == value.size()) {
1566 value.emplace_back();
1569 ArrayLengthField<T, InnerLenT...> field{value[index]};
1574 }
else if constexpr (std::is_same_v<T, bool>) {
1575 bool element =
false;
1581 if (index < value.size()) {
1582 value[index] = element;
1584 value.emplace_back(element);
1587 if (index == value.size()) {
1588 value.emplace_back();
1598 if constexpr (is_variable_size<T>()) {
1605 value.resize(index);
1610 template <
typename T,
size_t SizeT,
size_t... InnerLenT>
1612 std::index_sequence<InnerLenT...> = {}) noexcept {
1613 for (
size_t index = 0U; index < SizeT; ++index) {
1614 if constexpr (
sizeof...(InnerLenT) > 0U) {
1615 ArrayLengthField<T, InnerLenT...> field{value[index]};
1626 if constexpr (is_variable_size<T>()) {
1636 template <
typename KeyT,
typename ValueT,
typename CompareT,
typename AllocatorT>
1641 template <
typename KeyT,
typename ValueT,
typename HashT,
typename EqualT,
typename AllocatorT>
1643 size_t end) noexcept {
1647 template <
typename T,
size_t LenT,
size_t... InnerLenT>
1649 return read_value_body(reader, field.value, end, std::index_sequence<InnerLenT...>{});
1652 template <
typename... AlternativeT>
1654 static_assert(validate_union_alternatives<AlternativeT...>(),
"SOME/IP union alternatives are invalid.");
1656 uint64_t selector = 0U;
1662 return (selector != 0U || reader.
position() == end) &&
1663 read_union_alternative(reader, value, selector, end, std::make_index_sequence<
sizeof...(AlternativeT)>{});
1666 template <
typename MapT>
1671 const size_t entry_position = reader.
position();
1673 typename MapT::key_type key{};
1679 typename MapT::mapped_type mapped{};
1685 if VUNLIKELY (!value.emplace(std::move(key), std::move(mapped)).second) {
1693 template <
size_t IndexT,
typename... AlternativeT>
1695 if constexpr (IndexT == 0U && has_null_union_alternative<AlternativeT...>()) {
1696 value.template emplace<IndexT>();
1699 return read_value(reader, value.template emplace<IndexT>(), data_end);
1703 template <
typename... AlternativeT,
size_t... IndexT>
1705 size_t data_end, std::index_sequence<IndexT...>) noexcept {
1708 return ((selector == IndexT + (kHasNull ? 0U : 1U) && read_union_element<IndexT>(reader, value, data_end)) || ...);
1711 template <size_t LenT, size_t MaxT = std::numeric_limits<size_t>::max(),
typename T>
1713 static constexpr uint8_t kWireType = get_fixed_wire_type<T>();
1715 if constexpr (kWireType != kComplexWireType) {
1722 size_t body_end = 0U;
1728 bool body_ok =
false;
1730 if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, Bytes>) {
1732 }
else if constexpr (std::is_same_v<T, std::u16string>) {
1734 }
else if constexpr (
is_vector(
static_cast<const T*
>(
nullptr))) {
1735 body_ok = read_value_body<MaxT>(reader, value, body_end);
1740 return body_ok && reader.
skip(body_end - reader.
position(), body_end);
1744 template <u
int16_t DataIdT,
size_t LenT,
bool DynamicT,
typename T,
size_t MaxT>
1746 size_t end) noexcept {
1747 using ValueType = std::remove_cv_t<std::remove_reference_t<T>>;
1749 if constexpr (
is_optional(
static_cast<const ValueType*
>(
nullptr))) {
1750 if (!field.value.has_value()) {
1751 field.value.emplace();
1754 return read_tlv_value<LenT, MaxT>(reader, *field.value, wire_type, end);
1756 return read_tlv_value<LenT, MaxT>(reader, field.value, wire_type, end);
1760 template <u
int16_t DataIdT,
size_t LenT,
bool DynamicT,
size_t SizeT, Endian EncodingT,
typename T,
size_t MaxT>
1763 uint8_t wire_type,
size_t end) noexcept {
1764 using ValueType = std::remove_cv_t<T>;
1765 size_t body_end = 0U;
1768 body_end - reader.
position() > SizeT) {
1772 if constexpr (
is_optional(
static_cast<const ValueType*
>(
nullptr))) {
1773 if (!field.value.has_value()) {
1774 field.value.emplace();
1777 auto fixed = fixed_string_field<SizeT, 0U, EncodingT, MaxT>(*field.value);
1780 auto fixed = fixed_string_field<SizeT, 0U, EncodingT, MaxT>(field.value);
1785 template <uint16_t DataIdT,
size_t LenT,
bool DynamicT,
typename T,
size_t... InnerLenT>
1787 uint8_t wire_type,
size_t end) noexcept {
1788 using ValueType = std::remove_cv_t<T>;
1790 if constexpr (
is_optional(
static_cast<const ValueType*
>(
nullptr))) {
1791 if (!field.value.has_value()) {
1792 field.value.emplace();
1796 return read_tlv_value<LenT>(reader, array, wire_type, end);
1799 return read_tlv_value<LenT>(reader, array, wire_type, end);
1803 template <
typename T>
1805 using ValueType = std::remove_cv_t<std::remove_reference_t<T>>;
1807 if constexpr (
is_optional(
static_cast<const ValueType*
>(
nullptr))) {
1816 template <
size_t LenT,
typename TupleT,
size_t... IndexT>
1818 static constexpr
size_t kFieldCount =
sizeof...(IndexT);
1820 std::array<bool, kFieldCount> seen{};
1823 uint8_t wire_type = 0U;
1824 uint16_t data_id = 0U;
1830 bool field_ok =
true;
1832 const bool matched = ([&]() {
1833 using FieldType = std::remove_reference_t<std::tuple_element_t<IndexT, TupleT>>;
1835 if (FieldType::kDataId != data_id) {
1844 seen[IndexT] =
true;
1845 field_ok =
read_tlv_field(reader, std::get<IndexT>(fields), wire_type, end);
1859 bool required_ok =
true;
1866 template <
typename T>
1869 using FieldsType = decltype(value.get_vlink_someip_fields());
1871 static_assert(std::tuple_size_v<FieldsType> > 0U,
"SOME/IP structures must declare at least one field.");
1873 static constexpr
size_t kFieldCount = std::tuple_size_v<FieldsType>;
1874 static constexpr
size_t kTlvCount = count_tlv_fields<FieldsType>(std::make_index_sequence<kFieldCount>{});
1876 static_assert(kTlvCount == 0U || kTlvCount == kFieldCount,
1877 "SOME/IP structures must tag either every field or no field with VLINK_SOMEIP_TLV.");
1878 static_assert(kTlvCount == 0U || get_struct_length<T>() > 0U,
1879 "SOME/IP TLV structures must declare a non-zero VLINK_SOMEIP_STRUCT_LENGTH.");
1880 static_assert(kTlvCount == 0U || get_alignment<T>() == 1U,
"SOME/IP TLV structures require 1-byte alignment.");
1882 auto fields = value.get_vlink_someip_fields();
1884 if constexpr (kTlvCount > 0U) {
1885 static_assert(tlv_data_ids_are_unique<FieldsType>(std::make_index_sequence<kFieldCount>{}),
1886 "SOME/IP TLV data IDs must be unique within a structure.");
1889 "SOME/IP TLV fields must use the structure length width.");
1891 return read_tlv_fields<get_struct_length<T>()>(reader, fields, end, std::make_index_sequence<kFieldCount>{});
1893 return read_fields(reader, fields, end, std::make_index_sequence<kFieldCount>{});
1902 template <
size_t LenT,
typename T,
size_t MaxT>
1904 using ValueType = std::remove_cv_t<T>;
1906 if constexpr (std::is_same_v<ValueType, std::string> || std::is_same_v<ValueType, Bytes>) {
1908 }
else if constexpr (std::is_same_v<ValueType, std::u16string>) {
1910 }
else if constexpr (
is_vector(
static_cast<const ValueType*
>(
nullptr))) {
1911 return write_value<MaxT>(writer, field.value, LenT, std::index_sequence<>{});
1912 }
else if constexpr (
is_map(
static_cast<const ValueType*
>(
nullptr))) {
1915 return write_value(writer, field.value, LenT, std::index_sequence<>{});
1919 template <
typename T,
size_t LenT,
size_t... InnerLenT>
1921 return write_value(writer, field.value, LenT, std::index_sequence<InnerLenT...>{});
1924 template <
size_t LenT, Endian EncodingT,
typename T,
size_t MaxT>
1929 template <
size_t SizeT,
size_t LenT, Endian EncodingT,
typename T,
size_t MaxT>
1931 if constexpr (std::is_same_v<std::remove_cv_t<T>, std::string>) {
1938 template <
size_t SizeT,
size_t LenT, Endian EncodingT,
typename T,
size_t MaxT>
1940 if constexpr (std::is_same_v<std::remove_cv_t<T>, std::string>) {
1947 template <
size_t LenT,
size_t TypeT,
typename T>
1949 return write_value(writer, field.value, LenT, TypeT);
1952 template <
typename TupleT,
size_t... IndexT>
1953 inline bool write_fields(
Writer& writer,
const TupleT& fields, std::index_sequence<IndexT...>) noexcept {
1954 static constexpr
size_t kFieldCount = std::tuple_size_v<TupleT>;
1956 return ([&writer, &fields]() noexcept {
1961 using FieldType = std::remove_reference_t<std::tuple_element_t<IndexT, TupleT>>;
1963 return IndexT + 1U == kFieldCount || !is_variable_size<FieldType>() || writer.
align();
1967 template <
typename T,
typename AllocatorT,
size_t... InnerLenT>
1969 std::index_sequence<InnerLenT...> = {}) noexcept {
1970 for (
size_t index = 0U; index < value.size(); ++index) {
1971 const size_t element_position = writer.
position();
1973 if constexpr (
sizeof...(InnerLenT) > 0U) {
1974 const ArrayLengthField<
const T, InnerLenT...> field{value[index]};
1979 }
else if constexpr (std::is_same_v<T, bool>) {
1991 if constexpr (is_variable_size<T>()) {
2001 template <
typename T,
size_t SizeT,
size_t... InnerLenT>
2003 std::index_sequence<InnerLenT...> = {}) noexcept {
2004 for (
size_t index = 0U; index < SizeT; ++index) {
2005 if constexpr (
sizeof...(InnerLenT) > 0U) {
2006 const ArrayLengthField<
const T, InnerLenT...> field{value[index]};
2017 if constexpr (is_variable_size<T>()) {
2027 template <
typename KeyT,
typename ValueT,
typename CompareT,
typename AllocatorT>
2032 template <
typename KeyT,
typename ValueT,
typename HashT,
typename EqualT,
typename AllocatorT>
2034 const std::unordered_map<KeyT, ValueT, HashT, EqualT, AllocatorT>& value) noexcept {
2038 template <
typename T,
size_t LenT,
size_t... InnerLenT>
2040 return write_value_body(writer, field.value, std::index_sequence<InnerLenT...>{});
2043 template <
typename... AlternativeT>
2045 static_assert(validate_union_alternatives<AlternativeT...>(),
"SOME/IP union alternatives are invalid.");
2047 if VUNLIKELY (value.valueless_by_exception()) {
2052 const uint64_t selector = value.index() + (kHasNull ? 0U : 1U);
2058 template <
typename T>
2061 using FieldsType = decltype(value.get_vlink_someip_fields());
2063 static_assert(std::tuple_size_v<FieldsType> > 0U,
"SOME/IP structures must declare at least one field.");
2065 static constexpr
size_t kFieldCount = std::tuple_size_v<FieldsType>;
2066 static constexpr
size_t kTlvCount = count_tlv_fields<FieldsType>(std::make_index_sequence<kFieldCount>{});
2068 static_assert(kTlvCount == 0U || kTlvCount == kFieldCount,
2069 "SOME/IP structures must tag either every field or no field with VLINK_SOMEIP_TLV.");
2070 static_assert(kTlvCount == 0U || get_struct_length<T>() > 0U,
2071 "SOME/IP TLV structures must declare a non-zero VLINK_SOMEIP_STRUCT_LENGTH.");
2072 static_assert(kTlvCount == 0U || get_alignment<T>() == 1U,
"SOME/IP TLV structures require 1-byte alignment.");
2074 const auto fields = value.get_vlink_someip_fields();
2076 if constexpr (kTlvCount > 0U) {
2077 static_assert(tlv_data_ids_are_unique<FieldsType>(std::make_index_sequence<kFieldCount>{}),
2078 "SOME/IP TLV data IDs must be unique within a structure.");
2081 "SOME/IP TLV fields must use the structure length width.");
2083 return write_tlv_fields(writer, fields, std::make_index_sequence<kFieldCount>{});
2085 return write_fields(writer, fields, std::make_index_sequence<kFieldCount>{});
2094 template <
typename MapT>
2096 for (
const auto& entry : value) {
2097 const size_t entry_position = writer.
position();
2115 template <
size_t IndexT,
typename... AlternativeT>
2117 if constexpr (IndexT == 0U && has_null_union_alternative<AlternativeT...>()) {
2120 return write_value(writer, std::get<IndexT>(value));
2124 template <
typename... AlternativeT,
size_t... IndexT>
2126 std::index_sequence<IndexT...>) noexcept {
2127 return ((value.index() != IndexT || write_union_element<IndexT>(writer, value)) && ...);
2130 template <uint16_t DataIdT, size_t LenT, bool DynamicT, size_t MaxT = std::numeric_limits<size_t>::max(),
typename T>
2132 static constexpr uint8_t kWireType = get_fixed_wire_type<T>();
2134 if constexpr (kWireType != kComplexWireType) {
2137 const auto write_body = [&value](
Writer& target) noexcept {
2138 if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, Bytes>) {
2140 }
else if constexpr (std::is_same_v<T, std::u16string>) {
2142 }
else if constexpr (
is_vector(
static_cast<const T*
>(
nullptr))) {
2153 size_t length_width = LenT;
2154 size_t body_size = 0U;
2156 if constexpr (DynamicT) {
2158 const size_t start = sizing.
position();
2164 body_size = sizing.
position() - start;
2166 if VLIKELY (body_size <= std::numeric_limits<uint8_t>::max()) {
2168 }
else if (body_size <= std::numeric_limits<uint16_t>::max()) {
2175 size_t length_position = 0U;
2176 size_t data_position = 0U;
2182 if constexpr (DynamicT) {
2184 return writer.
append(
nullptr, body_size) &&
2189 return write_body(writer) && writer.
end_length_delimited(length_position, data_position, length_width);
2193 template <u
int16_t DataIdT,
size_t LenT,
bool DynamicT,
typename T,
size_t MaxT>
2195 using ValueType = std::remove_cv_t<std::remove_reference_t<T>>;
2197 if constexpr (
is_optional(
static_cast<const ValueType*
>(
nullptr))) {
2198 if (!field.value.has_value()) {
2202 return write_tlv_value<DataIdT, LenT, DynamicT, MaxT>(writer, *field.value);
2204 return write_tlv_value<DataIdT, LenT, DynamicT, MaxT>(writer, field.value);
2208 template <u
int16_t DataIdT,
size_t LenT,
bool DynamicT,
size_t SizeT, Endian EncodingT,
typename T,
size_t MaxT>
2211 using ValueType = std::remove_cv_t<T>;
2213 const auto write_fixed = [&writer](
const auto& value) noexcept {
2214 size_t length_width = LenT;
2215 if constexpr (DynamicT) {
2216 if constexpr (SizeT <= std::numeric_limits<uint8_t>::max()) {
2218 }
else if constexpr (SizeT <= std::numeric_limits<uint16_t>::max()) {
2225 size_t length_position = 0U;
2226 size_t data_position = 0U;
2227 const auto fixed = fixed_string_field<SizeT, 0U, EncodingT, MaxT>(value);
2233 if constexpr (
is_optional(
static_cast<const ValueType*
>(
nullptr))) {
2234 if (!field.value.has_value()) {
2238 return write_fixed(*field.value);
2240 return write_fixed(field.value);
2244 template <uint16_t DataIdT,
size_t LenT,
bool DynamicT,
typename T,
size_t... InnerLenT>
2247 using ValueType = std::remove_cv_t<T>;
2249 if constexpr (
is_optional(
static_cast<const ValueType*
>(
nullptr))) {
2250 if (!field.value.has_value()) {
2255 return write_tlv_value<DataIdT, LenT, DynamicT>(writer, array);
2258 return write_tlv_value<DataIdT, LenT, DynamicT>(writer, array);
2262 template <
typename TupleT,
size_t... IndexT>
2280 #define VLINK_SOMEIP_ALIGNMENT(alignment) \
2281 [[nodiscard]] static constexpr size_t vlink_someip_alignment() noexcept { return alignment; }
2288 #define VLINK_SOMEIP_ENDIAN(endian) \
2289 [[nodiscard]] static constexpr vlink::SomeipSerializer::Endian vlink_someip_endian() noexcept { return endian; }
2295 #define VLINK_SOMEIP_ENDIAN_BIG VLINK_SOMEIP_ENDIAN(vlink::SomeipSerializer::Endian::kBig)
2301 #define VLINK_SOMEIP_ENDIAN_LITTLE VLINK_SOMEIP_ENDIAN(vlink::SomeipSerializer::Endian::kLittle)
2308 #define VLINK_SOMEIP_STRUCT_LENGTH(width) \
2309 [[nodiscard]] static constexpr size_t vlink_someip_struct_length() noexcept { return width; }
2317 #define VLINK_SOMEIP_LENGTH(field, width) vlink::SomeipSerializer::length_field<width>(field)
2323 #define VLINK_SOMEIP_LENGTH_MAX(field, width, maximum) vlink::SomeipSerializer::length_field<width, maximum>(field)
2331 #define VLINK_SOMEIP_ARRAY_LENGTH(field, ...) vlink::SomeipSerializer::array_length_field<__VA_ARGS__>(field)
2339 #define VLINK_SOMEIP_UTF16(field, width, endian) vlink::SomeipSerializer::utf16_field<width, endian>(field)
2345 #define VLINK_SOMEIP_UTF16_MAX(field, width, endian, maximum) \
2346 vlink::SomeipSerializer::utf16_field<width, endian, maximum>(field)
2352 #define VLINK_SOMEIP_UTF16_BE(field, width) VLINK_SOMEIP_UTF16(field, width, vlink::SomeipSerializer::Endian::kBig)
2358 #define VLINK_SOMEIP_UTF16_LE(field, width) VLINK_SOMEIP_UTF16(field, width, vlink::SomeipSerializer::Endian::kLittle)
2365 #define VLINK_SOMEIP_FIXED_STRING(field, size, width) vlink::SomeipSerializer::fixed_string_field<size, width>(field)
2371 #define VLINK_SOMEIP_FIXED_STRING_MAX(field, size, width, maximum) \
2372 vlink::SomeipSerializer::fixed_string_field<size, width, vlink::SomeipSerializer::Endian::kBig, maximum>(field)
2378 #define VLINK_SOMEIP_FIXED_UTF16_BE(field, size, width) \
2379 vlink::SomeipSerializer::fixed_string_field<size, width, vlink::SomeipSerializer::Endian::kBig>(field)
2385 #define VLINK_SOMEIP_FIXED_UTF16_BE_MAX(field, size, width, maximum) \
2386 vlink::SomeipSerializer::fixed_string_field<size, width, vlink::SomeipSerializer::Endian::kBig, maximum>(field)
2392 #define VLINK_SOMEIP_FIXED_UTF16_LE(field, size, width) \
2393 vlink::SomeipSerializer::fixed_string_field<size, width, vlink::SomeipSerializer::Endian::kLittle>(field)
2399 #define VLINK_SOMEIP_FIXED_UTF16_LE_MAX(field, size, width, maximum) \
2400 vlink::SomeipSerializer::fixed_string_field<size, width, vlink::SomeipSerializer::Endian::kLittle, maximum>(field)
2410 #define VLINK_SOMEIP_UNION(field, length_width, type_width) \
2411 vlink::SomeipSerializer::union_field<length_width, type_width>(field)
2423 #define VLINK_SOMEIP_TLV(data_id, field) vlink::SomeipSerializer::tlv_field<data_id>(field)
2431 #define VLINK_SOMEIP_TLV_LENGTH(data_id, field, width) vlink::SomeipSerializer::tlv_field<data_id, width>(field)
2437 #define VLINK_SOMEIP_TLV_LENGTH_MAX(data_id, field, width, maximum) \
2438 vlink::SomeipSerializer::tlv_field<data_id, width, true, maximum>(field)
2444 #define VLINK_SOMEIP_TLV_FIXED_STRING(data_id, field, size, width, endian) \
2445 vlink::SomeipSerializer::tlv_fixed_string_field<data_id, width, true, size, endian>(field)
2451 #define VLINK_SOMEIP_TLV_FIXED_STRING_MAX(data_id, field, size, width, endian, maximum) \
2452 vlink::SomeipSerializer::tlv_fixed_string_field<data_id, width, true, size, endian, maximum>(field)
2459 #define VLINK_SOMEIP_TLV_ARRAY_LENGTH(data_id, field, width, ...) \
2460 vlink::SomeipSerializer::tlv_array_field<data_id, width, true, __VA_ARGS__>(field)
2468 #define VLINK_SOMEIP_TLV_STATIC_LENGTH(data_id, field, width) \
2469 vlink::SomeipSerializer::tlv_field<data_id, width, false>(field)
2475 #define VLINK_SOMEIP_TLV_STATIC_LENGTH_MAX(data_id, field, width, maximum) \
2476 vlink::SomeipSerializer::tlv_field<data_id, width, false, maximum>(field)
2482 #define VLINK_SOMEIP_TLV_STATIC_FIXED_STRING(data_id, field, size, width, endian) \
2483 vlink::SomeipSerializer::tlv_fixed_string_field<data_id, width, false, size, endian>(field)
2489 #define VLINK_SOMEIP_TLV_STATIC_FIXED_STRING_MAX(data_id, field, size, width, endian, maximum) \
2490 vlink::SomeipSerializer::tlv_fixed_string_field<data_id, width, false, size, endian, maximum>(field)
2497 #define VLINK_SOMEIP_TLV_STATIC_ARRAY_LENGTH(data_id, field, width, ...) \
2498 vlink::SomeipSerializer::tlv_array_field<data_id, width, false, __VA_ARGS__>(field)
2517 #define VLINK_SOMEIP_FIELDS(...) \
2518 [[nodiscard]] static constexpr bool is_vlink_someip_type() noexcept { return true; } \
2520 [[nodiscard]] auto get_vlink_someip_fields() noexcept { return vlink::SomeipSerializer::make_fields(__VA_ARGS__); } \
2522 [[nodiscard]] auto get_vlink_someip_fields() const noexcept { \
2523 return vlink::SomeipSerializer::make_fields(__VA_ARGS__); \
2526 [[nodiscard]] size_t get_serialized_size() const noexcept { \
2527 return vlink::SomeipSerializer::get_serialized_size(*this); \
2530 bool serialize(vlink::Bytes& out, uint8_t offset = 0U) const noexcept { \
2531 return vlink::SomeipSerializer::serialize(*this, out, offset); \
2534 bool deserialize(const vlink::Bytes& in) noexcept { return vlink::SomeipSerializer::deserialize(in, *this); } \
2536 bool operator>>(vlink::Bytes& out) const noexcept { return serialize(out); } \
2538 bool operator<<(const vlink::Bytes& in) noexcept { return deserialize(in); }
Fixed-size 128-byte buffer holder with SBO, five ownership modes and integrated codecs.
Definition: bytes.h:120
Bounds-checked SOME/IP payload reader.
Definition: someip_serializer.h:234
Reader(const uint8_t *data, size_t size, size_t alignment=1U, Endian endian=Endian::kBig) noexcept
Creates a reader over an immutable size-byte payload.
size_t position() const noexcept
Returns the current read position.
size_t size() const noexcept
Returns the total payload size.
bool align(size_t end) noexcept
Skips bytes up to the configured AUTOSAR alignment.
bool skip(size_t size, size_t end) noexcept
Advances by size bytes without exceeding end.
bool read_unsigned(uint64_t &value, size_t width, size_t end) noexcept
Reads a width-byte unsigned integer in the configured byte order.
Bounds-checked SOME/IP payload writer.
Definition: someip_serializer.h:105
bool is_size_only() const noexcept
Reports whether this writer only measures encoded size.
bool end_length_delimited(size_t length_position, size_t data_position, size_t width=sizeof(uint32_t)) noexcept
Finalizes a reserved length field from the current position.
size_t position() const noexcept
Returns the number of bytes consumed by this writer.
bool append_unsigned(uint64_t value, size_t width) noexcept
Appends the low width bytes of value in the configured byte order.
bool append(const uint8_t *data, size_t size) noexcept
Appends size bytes without alignment padding.
Writer(uint8_t *data, size_t capacity, size_t alignment=1U, Endian endian=Endian::kBig) noexcept
Creates a writer over data with capacity bytes.
Writer size_only() const noexcept
Creates a size-only cursor at the current position.
bool align() noexcept
Pads the current position to the configured AUTOSAR alignment.
bool begin_length_delimited(size_t &length_position, size_t &data_position, size_t width=sizeof(uint32_t)) noexcept
Reserves a length field and records its payload start.
#define VUNLIKELY(...)
Short alias for VLINK_UNLIKELY.
Definition: macros.h:292
#define VLINK_EXPORT
Definition: macros.h:81
#define VLIKELY(...)
Short alias for VLINK_LIKELY.
Definition: macros.h:284
VLINK_EXPORT void report_check_available_failure() noexcept
VLINK_EXPORT bool write_fixed_value(Writer &writer, const std::u16string &value, size_t size, size_t len, Endian encoding, size_t maximum=std::numeric_limits< size_t >::max()) noexcept
VLINK_EXPORT bool write_value_body(Writer &writer, const std::string &value, size_t maximum=std::numeric_limits< size_t >::max()) noexcept
VLINK_EXPORT bool write_union_frame(Writer &writer, uint64_t selector, size_t len, size_t type_width, size_t &length_position, size_t &content_position) noexcept
VLINK_EXPORT bool write_tag(Writer &writer, uint8_t wire_type, uint16_t data_id) noexcept
VLINK_EXPORT bool read_tag(Reader &reader, uint8_t &wire_type, uint16_t &data_id, size_t end) noexcept
VLINK_EXPORT bool write_fixed_value(Writer &writer, const std::string &value, size_t size, size_t len, size_t maximum=std::numeric_limits< size_t >::max()) noexcept
VLINK_EXPORT bool begin_tlv_complex(Writer &writer, uint16_t data_id, size_t len, bool dynamic, size_t &length_position, size_t &data_position) noexcept
VLINK_EXPORT bool read_fixed_value(Reader &reader, std::string &value, size_t end, size_t size, size_t len, size_t maximum=std::numeric_limits< size_t >::max()) noexcept
VLINK_EXPORT bool skip_tlv_value(Reader &reader, uint8_t wire_type, size_t configured_len, size_t end) noexcept
VLINK_EXPORT bool begin_tlv_body(Reader &reader, uint8_t wire_type, size_t configured_len, size_t end, size_t &body_end) noexcept
VLINK_EXPORT bool read_union_frame(Reader &reader, size_t len, size_t type_width, size_t end, uint64_t &selector, size_t &data_end) noexcept
VLINK_EXPORT bool write_value(Writer &writer, bool value) noexcept
VLINK_EXPORT bool prepare_destination(Bytes &des, size_t size, uint8_t offset) noexcept
VLINK_EXPORT bool read_fixed_value(Reader &reader, std::u16string &value, size_t end, size_t size, size_t len, Endian encoding, size_t maximum=std::numeric_limits< size_t >::max()) noexcept
VLINK_EXPORT bool read_value_body(Reader &reader, std::string &value, size_t end, size_t maximum=std::numeric_limits< size_t >::max()) noexcept
VLINK_EXPORT bool read_value(Reader &reader, bool &value, size_t end) noexcept
constexpr bool tlv_data_ids_are_unique(std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:1074
auto union_field(T &value) noexcept
Definition: someip_serializer.h:1024
bool write_fields(Writer &writer, const TupleT &fields, std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:1953
constexpr bool fields_are_variable(std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:1095
bool write_tlv_value(Writer &writer, const T &value) noexcept
Definition: someip_serializer.h:2131
constexpr bool is_tlv_field(const T *) noexcept
Definition: someip_serializer.h:1046
constexpr bool is_map(const T *) noexcept
Definition: someip_serializer.h:756
constexpr size_t get_alignment() noexcept
Definition: someip_serializer.h:720
bool finish_missing_tlv_value(T &value) noexcept
Definition: someip_serializer.h:1804
constexpr bool tlv_length_widths_are_equal(std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:1090
bool write_value(Writer &writer, const T &value) noexcept
Encodes an enum or macro-declared nested SOME/IP structure.
Definition: someip_serializer.h:1182
size_t get_serialized_size(const T &src) noexcept
Returns the exact SOME/IP payload size for src.
Definition: someip_serializer.h:1426
bool serialize(const T &src, Bytes &des) noexcept
Serializes src into des using the SOME/IP payload format.
Definition: someip_serializer.h:1433
bool read_fields(Reader &reader, TupleT &fields, size_t end, std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:1529
constexpr bool union_alternatives_have_equal_size(const std::variant< FirstT, AlternativeT... > *) noexcept
Definition: someip_serializer.h:851
Endian
Byte order used for SOME/IP payload scalar values.
Definition: someip_serializer.h:89
constexpr bool is_vector(const T *) noexcept
Definition: someip_serializer.h:771
auto length_field(T &value) noexcept
Definition: someip_serializer.h:995
bool read_map_entries(Reader &reader, MapT &value, size_t end) noexcept
Definition: someip_serializer.h:1667
bool write_union_alternative(Writer &writer, const std::variant< AlternativeT... > &value, std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:2125
bool deserialize(const Bytes &src, T &des) noexcept
Deserializes a complete SOME/IP payload from src into des.
Definition: someip_serializer.h:1461
constexpr bool is_variable_size() noexcept
Reports whether T encodes with a runtime-variable byte length.
Definition: someip_serializer.h:1175
constexpr bool is_optional(const T *) noexcept
Definition: someip_serializer.h:791
auto utf16_field(T &value) noexcept
Definition: someip_serializer.h:1013
bool read_union_alternative(Reader &reader, std::variant< AlternativeT... > &value, uint64_t selector, size_t data_end, std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:1704
bool write_tlv_fields(Writer &writer, const TupleT &fields, std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:2263
constexpr size_t count_tlv_fields(std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:1067
constexpr Endian get_endian() noexcept
Definition: someip_serializer.h:734
constexpr bool is_variant(const T *) noexcept
Definition: someip_serializer.h:781
auto tlv_field(T &value) noexcept
Definition: someip_serializer.h:1030
bool read_tlv_value(Reader &reader, T &value, uint8_t wire_type, size_t end) noexcept
Definition: someip_serializer.h:1712
constexpr bool validate_union_alternatives() noexcept
Definition: someip_serializer.h:837
constexpr bool has_null_union_alternative() noexcept
Definition: someip_serializer.h:858
bool write_union_element(Writer &writer, const std::variant< AlternativeT... > &value) noexcept
Definition: someip_serializer.h:2116
bool write_value_body(Writer &writer, const T &value) noexcept
Definition: someip_serializer.h:2059
auto tlv_fixed_string_field(T &value) noexcept
Definition: someip_serializer.h:1036
auto array_length_field(T &value) noexcept
Definition: someip_serializer.h:1008
constexpr bool supports_length_field(const T *) noexcept
Definition: someip_serializer.h:863
bool read_tlv_field(Reader &reader, TlvField< DataIdT, LenT, DynamicT, T, MaxT > &field, uint8_t wire_type, size_t end) noexcept
Definition: someip_serializer.h:1745
auto fixed_string_field(T &value) noexcept
Definition: someip_serializer.h:1019
auto tlv_array_field(T &value) noexcept
Definition: someip_serializer.h:1041
constexpr size_t get_struct_length() noexcept
Definition: someip_serializer.h:743
bool read_value_body(Reader &reader, T &value, size_t end) noexcept
Definition: someip_serializer.h:1867
bool read_tlv_fields(Reader &reader, TupleT &fields, size_t end, std::index_sequence< IndexT... >) noexcept
Definition: someip_serializer.h:1817
bool read_value(Reader &reader, T &value, size_t end) noexcept
Decodes an enum or macro-declared nested SOME/IP structure.
Definition: someip_serializer.h:1316
bool read_union_element(Reader &reader, std::variant< AlternativeT... > &value, size_t data_end) noexcept
Definition: someip_serializer.h:1694
constexpr bool supports_maximum(const T *) noexcept
Definition: someip_serializer.h:801
bool write_map_entries(Writer &writer, const MapT &value) noexcept
Definition: someip_serializer.h:2095
constexpr uint8_t get_fixed_wire_type() noexcept
Definition: someip_serializer.h:816
bool write_tlv_field(Writer &writer, const TlvField< DataIdT, LenT, DynamicT, T, MaxT > &field) noexcept
Definition: someip_serializer.h:2194
auto make_fields(FieldT &&... field) noexcept
Definition: someip_serializer.h:990
Definition: someip_serializer.h:887
T & value
Definition: someip_serializer.h:892
std::remove_cv_t< T > ValueType
Definition: someip_serializer.h:888
Definition: someip_serializer.h:911
std::remove_cv_t< T > ValueType
Definition: someip_serializer.h:912
T & value
Definition: someip_serializer.h:915
Definition: someip_serializer.h:879
T & value
Definition: someip_serializer.h:881
Definition: someip_serializer.h:978
static constexpr uint16_t kDataId
Definition: someip_serializer.h:979
T & value
Definition: someip_serializer.h:982
static constexpr size_t kLengthWidth
Definition: someip_serializer.h:980
Definition: someip_serializer.h:941
T & value
Definition: someip_serializer.h:945
Definition: someip_serializer.h:955
std::remove_cv_t< T > ValueType
Definition: someip_serializer.h:956
static constexpr size_t kLengthWidth
Definition: someip_serializer.h:961
T & value
Definition: someip_serializer.h:963
static constexpr bool kUtf16
Definition: someip_serializer.h:957
static constexpr uint16_t kDataId
Definition: someip_serializer.h:960
Definition: someip_serializer.h:927
T & value
Definition: someip_serializer.h:929
Definition: someip_serializer.h:902
T & value
Definition: someip_serializer.h:903
Type trait that always derives from std::false_type for any T.
Definition: traits.h:103
#define VLINK_HAS_MEMBER(T, member)
Macro Definitions
Definition: traits.h:325