1 /* 2 * Copyright (C) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #ifndef HDC_SERIAL_STRUCT_DEFINE_H 16 #define HDC_SERIAL_STRUCT_DEFINE_H 17 18 #include <cmath> 19 #include <cstdint> 20 #include <cstring> 21 #include <map> 22 #include <optional> 23 #include <string> 24 #include <tuple> 25 #include <variant> 26 #include <vector> 27 28 #include <securec.h> 29 30 // static file define. No need not modify. by zako 31 namespace Hdc { 32 // clang-format off 33 namespace SerialStruct { 34 namespace SerialDetail { 35 template<class MemPtrT> struct MemPtr { 36 }; 37 template<class T, class U> struct MemPtr<U T::*> { 38 using type = T; 39 using MemberType = U; 40 }; 41 template<class... Fields> struct MessageImpl { 42 public: 43 MessageImpl(Fields &&... fields) 44 : _fields(std::move(fields)...) 45 { 46 } 47 48 template<class Handler> void Visit(Handler &&handler) const 49 { 50 VisitImpl(std::forward<Handler>(handler), std::make_index_sequence<sizeof...(Fields)>()); 51 } 52 53 private: 54 std::tuple<Fields...> _fields; 55 56 template<class Handler, size_t... I> void VisitImpl(Handler &&handler, std::index_sequence<I...>) const 57 { 58 (handler(std::get<I>(_fields)), ...); 59 } 60 }; 61 62 template<uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> struct FieldImpl { 63 using type = typename SerialDetail::MemPtr<MemPtrT>::type; 64 using MemberType = typename SerialDetail::MemPtr<MemPtrT>::MemberType; 65 constexpr static const uint32_t tag = Tag; 66 constexpr static const uint32_t flags = Flags; 67 const std::string field_name; 68 69 static decltype(auto) get(const type &value) 70 { 71 return value.*MemPtr; 72 } 73 74 static decltype(auto) get(type &value) 75 { 76 return value.*MemPtr; 77 } 78 }; 79 80 template<uint32_t Tag, size_t Index, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> struct OneofFieldImpl { 81 using type = typename SerialDetail::MemPtr<MemPtrT>::type; 82 using MemberType = typename SerialDetail::MemPtr<MemPtrT>::MemberType; 83 constexpr static const uint32_t tag = Tag; 84 constexpr static const size_t index = Index; 85 constexpr static const uint32_t flags = Flags; 86 const std::string field_name; 87 88 static decltype(auto) get(const type &value) 89 { 90 return value.*MemPtr; 91 } 92 93 static decltype(auto) get(type &value) 94 { 95 return value.*MemPtr; 96 } 97 }; 98 99 template<uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t KeyFlags, uint32_t ValueFlags> 100 struct MapFieldImpl { 101 using type = typename SerialDetail::MemPtr<MemPtrT>::type; 102 using MemberType = typename SerialDetail::MemPtr<MemPtrT>::MemberType; 103 constexpr static const uint32_t tag = Tag; 104 constexpr static const uint32_t KEY_FLAGS = KeyFlags; 105 constexpr static const uint32_t VALUE_FLAGS = ValueFlags; 106 107 const std::string field_name; 108 109 static decltype(auto) get(const type &value) 110 { 111 return value.*MemPtr; 112 } 113 114 static decltype(auto) get(type &value) 115 { 116 return value.*MemPtr; 117 } 118 }; 119 } 120 121 enum class WireType : uint32_t { 122 VARINT = 0, 123 FIXED64 = 1, 124 LENGTH_DELIMETED = 2, 125 START_GROUP = 3, 126 END_GROUP = 4, 127 FIXED32 = 5, 128 }; 129 enum Flags { NO = 0, S = 1, F = 2 }; 130 template<uint32_t flags = Flags::NO> struct FlagsType { 131 }; 132 133 template<class T> struct Descriptor { 134 static_assert(sizeof(T) == 0, "You need to implement descriptor for your own types"); 135 static void type() 136 { 137 } 138 }; 139 140 template<class... Fields> constexpr auto Message(Fields &&... fields) 141 { 142 return SerialDetail::MessageImpl<Fields...>(std::forward<Fields>(fields)...); 143 } 144 145 template<uint32_t Tag, auto MemPtr, uint32_t Flags = Flags::NO> constexpr auto Field(const std::string &fieldName) 146 { 147 return SerialDetail::FieldImpl<Tag, decltype(MemPtr), MemPtr, Flags> { fieldName }; 148 } 149 150 template<uint32_t Tag, size_t Index, auto MemPtr, uint32_t Flags = Flags::NO> 151 constexpr auto OneofField(const std::string &fieldName) 152 { 153 return SerialDetail::OneofFieldImpl<Tag, Index, decltype(MemPtr), MemPtr, Flags> { fieldName }; 154 } 155 156 template<uint32_t Tag, auto MemPtr, uint32_t KeyFlags = Flags::NO, uint32_t ValueFlags = Flags::NO> 157 constexpr auto MapField(const std::string &fieldName) 158 { 159 return SerialDetail::MapFieldImpl<Tag, decltype(MemPtr), MemPtr, KeyFlags, ValueFlags> { fieldName }; 160 } 161 162 template<class T> const auto &MessageType() 163 { 164 static const auto message = Descriptor<T>::type(); 165 return message; 166 } 167 168 template<class T, class Enable = void> struct Serializer; 169 170 struct Writer { 171 virtual void Write(const void *bytes, size_t size) = 0; 172 }; 173 174 struct Reader { 175 virtual size_t Read(void *bytes, size_t size) = 0; 176 }; 177 178 namespace SerialDetail { 179 template<class T, class V, class F, class W, class Enable = void> 180 struct HasSerializePacked : public std::false_type { 181 }; 182 183 template<class T, class V, class F, class W> 184 struct HasSerializePacked<T, V, F, W, 185 std::void_t<decltype(std::declval<T>().SerializePacked( 186 std::declval<V>(), std::declval<F>(), std::declval<W &>()))>> : public std::true_type { 187 }; 188 189 template<class T, class V, class F, class W> 190 constexpr bool HAS_SERIALIZE_PACKED_V = HasSerializePacked<T, V, F, W>::value; 191 192 template<class T, class V, class F, class R, class Enable = void> 193 struct HasParsePacked : public std::false_type { 194 }; 195 196 template<class T, class V, class F, class R> 197 struct HasParsePacked<T, V, F, R, 198 std::void_t<decltype(std::declval<T>().ParsePacked( 199 std::declval<V &>(), std::declval<F>(), std::declval<R &>()))>> : public std::true_type { 200 }; 201 202 template<class T, class V, class F, class R> 203 constexpr bool HAS_PARSE_PACKED_V = HasParsePacked<T, V, F, R>::value; 204 205 static uint32_t MakeTagWireType(uint32_t tag, WireType wireType) 206 { 207 return (tag << 3) | static_cast<uint32_t>(wireType); 208 } 209 210 static inline void ReadTagWireType(uint32_t tagKey, uint32_t &tag, WireType &wireType) 211 { 212 wireType = static_cast<WireType>(tagKey & 0b0111); 213 tag = tagKey >> 3; 214 } 215 216 static uint32_t MakeZigzagValue(int32_t value) 217 { 218 return (static_cast<uint32_t>(value) << 1) ^ static_cast<uint32_t>(value >> 31); 219 } 220 221 static uint64_t MakeZigzagValue(int64_t value) 222 { 223 return (static_cast<uint64_t>(value) << 1) ^ static_cast<uint64_t>(value >> 63); 224 } 225 226 static int32_t ReadZigzagValue(uint32_t value) 227 { 228 return static_cast<int32_t>((value >> 1) ^ (~(value & 1) + 1)); 229 } 230 231 static int64_t ReadZigzagValue(uint64_t value) 232 { 233 return static_cast<int64_t>((value >> 1) ^ (~(value & 1) + 1)); 234 } 235 236 template<class To, class From> To BitCast(From from) 237 { 238 static_assert(sizeof(To) == sizeof(From), ""); 239 static_assert(std::is_trivially_copyable_v<To>, ""); 240 static_assert(std::is_trivially_copyable_v<From>, ""); 241 To to; 242 memcpy_s(&to, sizeof(To), &from, sizeof(from)); 243 return to; 244 } 245 246 struct WriterSizeCollector : public Writer { 247 void Write(const void *, size_t size) override 248 { 249 byte_size += size; 250 } 251 size_t byte_size = 0; 252 }; 253 254 struct LimitedReader : public Reader { 255 LimitedReader(Reader &parent, size_t sizeLimit) 256 : _parent(parent), _size_limit(sizeLimit) 257 { 258 } 259 260 size_t Read(void *bytes, size_t size) override 261 { 262 auto sizeToRead = std::min(size, _size_limit); 263 auto readSize = _parent.Read(bytes, sizeToRead); 264 _size_limit -= readSize; 265 return readSize; 266 } 267 268 size_t AvailableBytes() const 269 { 270 return _size_limit; 271 } 272 273 private: 274 Reader &_parent; 275 size_t _size_limit; 276 }; 277 278 static bool ReadByte(uint8_t &value, Reader &in) 279 { 280 return in.Read(&value, 1) == 1; 281 } 282 283 static void WriteVarint(uint32_t value, Writer &out) 284 { 285 uint8_t b[5] {}; 286 for (size_t i = 0; i < 5; ++i) { 287 b[i] = value & 0b0111'1111; 288 value >>= 7; 289 if (value) { 290 b[i] |= 0b1000'0000; 291 } else { 292 out.Write(b, i + 1); 293 break; 294 } 295 } 296 } 297 298 static void WriteVarint(uint64_t value, Writer &out) 299 { 300 uint8_t b[10] {}; 301 for (size_t i = 0; i < 10; ++i) { 302 b[i] = value & 0b0111'1111; 303 value >>= 7; 304 if (value) { 305 b[i] |= 0b1000'0000; 306 } else { 307 out.Write(b, i + 1); 308 break; 309 } 310 } 311 } 312 313 #if defined(HOST_MAC) 314 static void WriteVarint(unsigned long value, Writer &out) 315 { 316 WriteVarint(static_cast<uint64_t>(value), out); 317 } 318 #endif 319 320 static bool ReadVarint(uint32_t &value, Reader &in) 321 { 322 value = 0; 323 for (size_t c = 0; c < 5; ++c) { 324 uint8_t x; 325 if (!ReadByte(x, in)) { 326 return false; 327 } 328 value |= static_cast<uint32_t>(x & 0b0111'1111) << 7 * c; 329 if (!(x & 0b1000'0000)) { 330 return true; 331 } 332 } 333 334 return false; 335 } 336 337 static bool ReadVarint(uint64_t &value, Reader &in) 338 { 339 value = 0; 340 for (size_t c = 0; c < 10; ++c) { 341 uint8_t x; 342 if (!ReadByte(x, in)) { 343 return false; 344 } 345 value |= static_cast<uint64_t>(x & 0b0111'1111) << 7 * c; 346 if (!(x & 0b1000'0000)) { 347 return true; 348 } 349 } 350 return false; 351 } 352 353 #if defined(HOST_MAC) 354 static bool ReadVarint(unsigned long &value, Reader &in) 355 { 356 uint64_t intermediateValue; 357 if (ReadVarint(intermediateValue, in)) { 358 value = static_cast<unsigned long>(intermediateValue); 359 return true; 360 } 361 return false; 362 } 363 #endif 364 365 static void WriteFixed(uint32_t value, Writer &out) 366 { 367 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 368 out.Write(&value, sizeof(value)); 369 #else 370 static_assert(false, "Not a little-endian"); 371 #endif 372 } 373 374 static void WriteFixed(uint64_t value, Writer &out) 375 { 376 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 377 out.Write(&value, sizeof(value)); 378 #else 379 static_assert(false, "Not a little-endian"); 380 #endif 381 } 382 383 static void WriteFixed(double value, Writer &out) 384 { 385 WriteFixed(BitCast<uint64_t>(value), out); 386 } 387 388 static void WriteFixed(float value, Writer &out) 389 { 390 WriteFixed(BitCast<uint32_t>(value), out); 391 } 392 393 static void WriteVarint(int32_t value, Writer &out) 394 { 395 WriteVarint(BitCast<uint32_t>(value), out); 396 } 397 398 static void WriteVarint(int64_t value, Writer &out) 399 { 400 WriteVarint(BitCast<uint64_t>(value), out); 401 } 402 403 static void WriteSignedVarint(int32_t value, Writer &out) 404 { 405 WriteVarint(MakeZigzagValue(value), out); 406 } 407 408 static void WriteSignedVarint(int64_t value, Writer &out) 409 { 410 WriteVarint(MakeZigzagValue(value), out); 411 } 412 413 static void WriteSignedFixed(int32_t value, Writer &out) 414 { 415 WriteFixed(static_cast<uint32_t>(value), out); 416 } 417 418 static void WriteSignedFixed(int64_t value, Writer &out) 419 { 420 WriteFixed(static_cast<uint64_t>(value), out); 421 } 422 423 static void WriteTagWriteType(uint32_t tag, WireType wireType, Writer &out) 424 { 425 WriteVarint(MakeTagWireType(tag, wireType), out); 426 } 427 428 static bool ReadFixed(uint32_t &value, Reader &in) 429 { 430 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 431 return in.Read(&value, sizeof(value)) == sizeof(value); 432 #else 433 static_assert(false, "Not a little-endian"); 434 #endif 435 } 436 437 static bool ReadFixed(uint64_t &value, Reader &in) 438 { 439 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 440 return in.Read(&value, sizeof(value)) == sizeof(value); 441 #else 442 static_assert(false, "Not a little-endian"); 443 #endif 444 } 445 446 static bool ReadFixed(double &value, Reader &in) 447 { 448 uint64_t intermediateValue; 449 if (ReadFixed(intermediateValue, in)) { 450 value = BitCast<double>(intermediateValue); 451 return true; 452 } 453 return false; 454 } 455 456 static bool ReadFixed(float &value, Reader &in) 457 { 458 uint32_t intermediateValue; 459 if (ReadFixed(intermediateValue, in)) { 460 value = BitCast<float>(intermediateValue); 461 return true; 462 } 463 return false; 464 } 465 466 static bool ReadVarint(int32_t &value, Reader &in) 467 { 468 uint32_t intermediateValue; 469 if (ReadVarint(intermediateValue, in)) { 470 value = BitCast<int32_t>(intermediateValue); 471 return true; 472 } 473 return false; 474 } 475 476 static bool ReadVarint(int64_t &value, Reader &in) 477 { 478 uint64_t intermediateValue; 479 if (ReadVarint(intermediateValue, in)) { 480 value = BitCast<int64_t>(intermediateValue); 481 return true; 482 } 483 return false; 484 } 485 486 static bool ReadSignedVarint(int32_t &value, Reader &in) 487 { 488 uint32_t intermediateValue; 489 if (ReadVarint(intermediateValue, in)) { 490 value = ReadZigzagValue(intermediateValue); 491 return true; 492 } 493 return false; 494 } 495 496 static bool ReadSignedVarint(int64_t &value, Reader &in) 497 { 498 uint64_t intermediateValue; 499 if (ReadVarint(intermediateValue, in)) { 500 value = ReadZigzagValue(intermediateValue); 501 return true; 502 } 503 return false; 504 } 505 506 static bool ReadSignedFixed(int32_t &value, Reader &in) 507 { 508 uint32_t intermediateValue; 509 if (ReadFixed(intermediateValue, in)) { 510 value = static_cast<int64_t>(intermediateValue); 511 return true; 512 } 513 return false; 514 } 515 516 static bool ReadSignedFixed(int64_t &value, Reader &in) 517 { 518 uint64_t intermediateValue; 519 if (ReadFixed(intermediateValue, in)) { 520 value = static_cast<int64_t>(intermediateValue); 521 return true; 522 } 523 return false; 524 } 525 526 template<class T, uint32_t Tag, size_t Index, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> 527 void WriteField(const T &value, 528 const SerialDetail::OneofFieldImpl<Tag, Index, MemPtrT, MemPtr, Flags> &, Writer &out) 529 { 530 using OneOf = SerialDetail::OneofFieldImpl<Tag, Index, MemPtrT, MemPtr, Flags>; 531 Serializer<typename OneOf::MemberType>::template SerializeOneof<OneOf::index>( 532 OneOf::tag, OneOf::get(value), FlagsType<OneOf::flags>(), out); 533 } 534 535 template<class T, uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t KeyFlags, uint32_t ValueFlags> 536 void WriteField(const T &value, 537 const SerialDetail::MapFieldImpl<Tag, MemPtrT, MemPtr, KeyFlags, ValueFlags> &, Writer &out) 538 { 539 using Map = SerialDetail::MapFieldImpl<Tag, MemPtrT, MemPtr, KeyFlags, ValueFlags>; 540 Serializer<typename Map::MemberType>::SerializeMap( 541 Map::tag, Map::get(value), FlagsType<Map::KEY_FLAGS>(), FlagsType<Map::VALUE_FLAGS>(), out); 542 } 543 544 template<class T, uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> 545 void WriteField(const T &value, const SerialDetail::FieldImpl<Tag, MemPtrT, MemPtr, Flags> &, Writer &out) 546 { 547 using Field = SerialDetail::FieldImpl<Tag, MemPtrT, MemPtr, Flags>; 548 Serializer<typename Field::MemberType>::Serialize( 549 Field::tag, Field::get(value), FlagsType<Field::flags>(), out); 550 } 551 552 template<class T, class... Field> 553 void WriteMessage(const T &value, const SerialDetail::MessageImpl<Field...> &message, Writer &out) 554 { 555 message.Visit([&](const auto &field) { WriteField(value, field, out); }); 556 } 557 558 template<uint32_t Flags, class ValueType, class It> 559 void WriteRepeated(uint32_t tag, It begin, It end, Writer &out) 560 { 561 if (begin == end) { 562 return; 563 } 564 if constexpr (SerialDetail::HAS_SERIALIZE_PACKED_V<Serializer<ValueType>, ValueType, FlagsType<Flags>, 565 Writer>) { 566 WriteVarint(MakeTagWireType(tag, WireType::LENGTH_DELIMETED), out); 567 WriterSizeCollector sizeCollector; 568 for (auto it = begin; it != end; ++it) { 569 Serializer<ValueType>::SerializePacked(*it, FlagsType<Flags> {}, sizeCollector); 570 } 571 WriteVarint(sizeCollector.byte_size, out); 572 for (auto it = begin; it != end; ++it) { 573 Serializer<ValueType>::SerializePacked(*it, FlagsType<Flags> {}, out); 574 } 575 } else { 576 for (auto it = begin; it != end; ++it) { 577 Serializer<ValueType>::Serialize(tag, *it, FlagsType<Flags>(), out); 578 } 579 } 580 } 581 582 template<uint32_t KeyFlags, uint32_t ValueFlags, class Key, class Value> 583 void WriteMapKeyValue(const std::pair<const Key, Value> &value, Writer &out) 584 { 585 Serializer<Key>::Serialize(1, value.first, FlagsType<KeyFlags> {}, out, true); 586 Serializer<Value>::Serialize(2, value.second, FlagsType<ValueFlags> {}, out, true); 587 } 588 589 template<uint32_t KeyFlags, uint32_t ValueFlags, class T> 590 void WriteMap(uint32_t tag, const T &value, Writer &out) 591 { 592 auto begin = std::begin(value); 593 auto end = std::end(value); 594 595 for (auto it = begin; it != end; ++it) { 596 WriteTagWriteType(tag, WireType::LENGTH_DELIMETED, out); 597 WriterSizeCollector sizeCollector; 598 WriteMapKeyValue<KeyFlags, ValueFlags>(*it, sizeCollector); 599 WriteVarint(sizeCollector.byte_size, out); 600 WriteMapKeyValue<KeyFlags, ValueFlags>(*it, out); 601 } 602 } 603 604 template<uint32_t KeyFlags, uint32_t ValueFlags, class Key, class Value> 605 bool ReadMapKeyValue(std::pair<Key, Value> &value, Reader &in) 606 { 607 static const auto pairAsMessage = Message(Field<1, &std::pair<Key, Value>::first, KeyFlags>("key"), 608 Field<2, &std::pair<Key, Value>::second, ValueFlags>("value")); 609 return ReadMessage(value, pairAsMessage, in); 610 } 611 612 template<uint32_t KeyFlags, uint32_t ValueFlags, class T> 613 bool ReadMap(WireType wireType, T &value, Reader &in) 614 { 615 if (wireType != WireType::LENGTH_DELIMETED) { 616 return false; 617 } 618 size_t size; 619 if (ReadVarint(size, in)) { 620 LimitedReader limitedIn(in, size); 621 while (limitedIn.AvailableBytes() > 0) { 622 std::pair<typename T::key_type, typename T::mapped_type> item; 623 if (!ReadMapKeyValue<KeyFlags, ValueFlags>(item, limitedIn)) { 624 return false; 625 } 626 value.insert(std::move(item)); 627 } 628 return true; 629 } 630 return false; 631 } 632 633 template<uint32_t Flags, class ValueType, class OutputIt> 634 bool ReadRepeated(WireType wireType, OutputIt output_it, Reader &in) 635 { 636 if constexpr (SerialDetail::HAS_PARSE_PACKED_V<Serializer<ValueType>, ValueType, FlagsType<Flags>, 637 Reader>) { 638 if (wireType != WireType::LENGTH_DELIMETED) { 639 return false; 640 } 641 642 size_t size; 643 if (ReadVarint(size, in)) { 644 LimitedReader limitedIn(in, size); 645 646 while (limitedIn.AvailableBytes() > 0) { 647 ValueType value; 648 if (!Serializer<ValueType>::ParsePacked(value, FlagsType<Flags>(), limitedIn)) { 649 return false; 650 } 651 output_it = value; 652 ++output_it; 653 } 654 return true; 655 } 656 return false; 657 } else { 658 ValueType value; 659 if (Serializer<ValueType>::Parse(wireType, value, FlagsType<Flags>(), in)) { 660 output_it = value; 661 ++output_it; 662 return true; 663 } 664 return false; 665 } 666 } 667 668 template<class T, uint32_t Tag, size_t Index, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> 669 void ReadField(T &value, uint32_t tag, WireType wireType, 670 const SerialDetail::OneofFieldImpl<Tag, Index, MemPtrT, MemPtr, Flags> &, Reader &in) 671 { 672 if (Tag != tag) { 673 return; 674 } 675 using OneOf = SerialDetail::OneofFieldImpl<Tag, Index, MemPtrT, MemPtr, Flags>; 676 Serializer<typename OneOf::MemberType>::template ParseOneof<OneOf::index>( 677 wireType, OneOf::get(value), FlagsType<OneOf::flags>(), in); 678 } 679 680 template<class T, uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t KeyFlags, uint32_t ValueFlags> 681 void ReadField(T &value, uint32_t tag, WireType wireType, 682 const SerialDetail::MapFieldImpl<Tag, MemPtrT, MemPtr, KeyFlags, ValueFlags> &, Reader &in) 683 { 684 if (Tag != tag) { 685 return; 686 } 687 using Map = SerialDetail::MapFieldImpl<Tag, MemPtrT, MemPtr, KeyFlags, ValueFlags>; 688 Serializer<typename Map::MemberType>::ParseMap( 689 wireType, Map::get(value), FlagsType<Map::KEY_FLAGS>(), FlagsType<Map::VALUE_FLAGS>(), in); 690 } 691 692 template<class T, uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> 693 void ReadField(T &value, uint32_t tag, WireType wireType, 694 const SerialDetail::FieldImpl<Tag, MemPtrT, MemPtr, Flags> &, Reader &in) 695 { 696 if (Tag != tag) { 697 return; 698 } 699 using Field = SerialDetail::FieldImpl<Tag, MemPtrT, MemPtr, Flags>; 700 Serializer<typename Field::MemberType>::Parse(wireType, Field::get(value), FlagsType<Field::flags>(), in); 701 } 702 703 template<class T, class... Field> bool ReadMessage(T &value, const MessageImpl<Field...> &message, Reader &in) 704 { 705 uint32_t tagKey; 706 while (ReadVarint(tagKey, in)) { 707 uint32_t tag; 708 WireType wireType; 709 ReadTagWireType(tagKey, tag, wireType); 710 message.Visit([&](const auto &field) { ReadField(value, tag, wireType, field, in); }); 711 } 712 return true; 713 } 714 } 715 716 template<class T, class Enable> struct Serializer { 717 // Commion Serializer threat type as Message 718 static void Serialize(uint32_t tag, const T &value, FlagsType<>, Writer &out, bool force = false) 719 { 720 SerialDetail::WriterSizeCollector sizeCollector; 721 SerialDetail::WriteMessage(value, MessageType<T>(), sizeCollector); 722 if (!force && sizeCollector.byte_size == 0) { 723 return; 724 } 725 SerialDetail::WriteTagWriteType(tag, WireType::LENGTH_DELIMETED, out); 726 SerialDetail::WriteVarint(sizeCollector.byte_size, out); 727 SerialDetail::WriteMessage(value, MessageType<T>(), out); 728 } 729 730 static bool Parse(WireType wireType, T &value, FlagsType<>, Reader &in) 731 { 732 if (wireType != WireType::LENGTH_DELIMETED) { 733 return false; 734 } 735 size_t size; 736 if (SerialDetail::ReadVarint(size, in)) { 737 SerialDetail::LimitedReader limitedIn(in, size); 738 return SerialDetail::ReadMessage(value, MessageType<T>(), limitedIn); 739 } 740 return false; 741 } 742 }; 743 744 template<> struct Serializer<int32_t> { 745 static void Serialize(uint32_t tag, int32_t value, FlagsType<>, Writer &out, bool force = false) 746 { 747 (void)force; 748 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 749 SerialDetail::WriteVarint(value, out); 750 } 751 752 static void Serialize(uint32_t tag, int32_t value, FlagsType<Flags::S>, Writer &out, bool force = false) 753 { 754 (void)force; 755 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 756 SerialDetail::WriteSignedVarint(value, out); 757 } 758 759 static void Serialize( 760 uint32_t tag, int32_t value, FlagsType<Flags::S | Flags::F>, Writer &out, bool force = false) 761 { 762 (void)force; 763 SerialDetail::WriteTagWriteType(tag, WireType::FIXED32, out); 764 SerialDetail::WriteSignedFixed(value, out); 765 } 766 767 static void SerializePacked(int32_t value, FlagsType<>, Writer &out) 768 { 769 SerialDetail::WriteVarint(value, out); 770 } 771 772 static void SerializePacked(int32_t value, FlagsType<Flags::S>, Writer &out) 773 { 774 SerialDetail::WriteSignedVarint(value, out); 775 } 776 777 static void SerializePacked(int32_t value, FlagsType<Flags::S | Flags::F>, Writer &out) 778 { 779 SerialDetail::WriteSignedFixed(value, out); 780 } 781 782 static bool Parse(WireType wire_type, int32_t &value, FlagsType<>, Reader &in) 783 { 784 if (wire_type != WireType::VARINT) 785 return false; 786 return SerialDetail::ReadVarint(value, in); 787 } 788 789 static bool Parse(WireType wire_type, int32_t &value, FlagsType<Flags::S>, Reader &in) 790 { 791 if (wire_type != WireType::VARINT) 792 return false; 793 return SerialDetail::ReadSignedVarint(value, in); 794 } 795 796 static bool Parse(WireType wire_type, int32_t &value, FlagsType<Flags::S | Flags::F>, Reader &in) 797 { 798 if (wire_type != WireType::FIXED32) 799 return false; 800 return SerialDetail::ReadSignedFixed(value, in); 801 } 802 803 static bool ParsePacked(int32_t &value, FlagsType<>, Reader &in) 804 { 805 return SerialDetail::ReadVarint(value, in); 806 } 807 808 static bool ParsePacked(int32_t &value, FlagsType<Flags::S>, Reader &in) 809 { 810 return SerialDetail::ReadSignedVarint(value, in); 811 } 812 813 static bool ParsePacked(int32_t &value, FlagsType<Flags::S | Flags::F>, Reader &in) 814 { 815 return SerialDetail::ReadSignedFixed(value, in); 816 } 817 }; 818 819 template<> struct Serializer<uint32_t> { 820 static void Serialize(uint32_t tag, uint32_t value, FlagsType<>, Writer &out, bool force = false) 821 { 822 (void)force; 823 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 824 SerialDetail::WriteVarint(value, out); 825 } 826 827 static void Serialize(uint32_t tag, uint32_t value, FlagsType<Flags::F>, Writer &out, bool force = false) 828 { 829 (void)force; 830 SerialDetail::WriteTagWriteType(tag, WireType::FIXED32, out); 831 SerialDetail::WriteFixed(value, out); 832 } 833 834 static void SerializePacked(uint32_t value, FlagsType<>, Writer &out) 835 { 836 SerialDetail::WriteVarint(value, out); 837 } 838 839 static void SerializePacked(uint32_t value, FlagsType<Flags::F>, Writer &out) 840 { 841 SerialDetail::WriteFixed(value, out); 842 } 843 844 static bool Parse(WireType wire_type, uint32_t &value, FlagsType<>, Reader &in) 845 { 846 if (wire_type != WireType::VARINT) 847 return false; 848 return SerialDetail::ReadVarint(value, in); 849 } 850 851 static bool Parse(WireType wire_type, uint32_t &value, FlagsType<Flags::F>, Reader &in) 852 { 853 if (wire_type != WireType::FIXED32) 854 return false; 855 return SerialDetail::ReadFixed(value, in); 856 } 857 858 static bool ParsePacked(uint32_t &value, FlagsType<>, Reader &in) 859 { 860 return SerialDetail::ReadVarint(value, in); 861 } 862 863 static bool ParsePacked(uint32_t &value, FlagsType<Flags::F>, Reader &in) 864 { 865 return SerialDetail::ReadFixed(value, in); 866 } 867 }; 868 869 template<> struct Serializer<int64_t> { 870 static void Serialize(uint32_t tag, int64_t value, FlagsType<>, Writer &out, bool force = false) 871 { 872 (void)force; 873 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 874 SerialDetail::WriteVarint(value, out); 875 } 876 877 static void Serialize(uint32_t tag, int64_t value, FlagsType<Flags::S>, Writer &out, bool force = false) 878 { 879 (void)force; 880 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 881 SerialDetail::WriteSignedVarint(value, out); 882 } 883 884 static void Serialize( 885 uint32_t tag, int64_t value, FlagsType<Flags::S | Flags::F>, Writer &out, bool force = false) 886 { 887 (void)force; 888 SerialDetail::WriteTagWriteType(tag, WireType::FIXED64, out); 889 SerialDetail::WriteSignedFixed(value, out); 890 } 891 892 static void SerializePacked(int64_t value, FlagsType<>, Writer &out) 893 { 894 SerialDetail::WriteVarint(value, out); 895 } 896 897 static void SerializePacked(int64_t value, FlagsType<Flags::S>, Writer &out) 898 { 899 SerialDetail::WriteSignedVarint(value, out); 900 } 901 902 static void SerializePacked(int64_t value, FlagsType<Flags::S | Flags::F>, Writer &out) 903 { 904 SerialDetail::WriteSignedFixed(value, out); 905 } 906 907 static bool Parse(WireType wire_type, int64_t &value, FlagsType<>, Reader &in) 908 { 909 if (wire_type != WireType::VARINT) 910 return false; 911 return SerialDetail::ReadVarint(value, in); 912 } 913 914 static bool Parse(WireType wire_type, int64_t &value, FlagsType<Flags::S>, Reader &in) 915 { 916 if (wire_type != WireType::VARINT) 917 return false; 918 return SerialDetail::ReadSignedVarint(value, in); 919 } 920 921 static bool Parse(WireType wire_type, int64_t &value, FlagsType<Flags::S | Flags::F>, Reader &in) 922 { 923 if (wire_type != WireType::FIXED64) 924 return false; 925 return SerialDetail::ReadSignedFixed(value, in); 926 } 927 928 static bool ParsePacked(int64_t &value, FlagsType<>, Reader &in) 929 { 930 return SerialDetail::ReadVarint(value, in); 931 } 932 933 static bool ParsePacked(int64_t &value, FlagsType<Flags::S>, Reader &in) 934 { 935 return SerialDetail::ReadSignedVarint(value, in); 936 } 937 938 static bool ParsePacked(int64_t &value, FlagsType<Flags::S | Flags::F>, Reader &in) 939 { 940 return SerialDetail::ReadSignedFixed(value, in); 941 } 942 }; 943 944 template<> struct Serializer<uint64_t> { 945 static void Serialize(uint32_t tag, uint64_t value, FlagsType<>, Writer &out, bool force = false) 946 { 947 (void)force; 948 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 949 SerialDetail::WriteVarint(value, out); 950 } 951 952 static void Serialize(uint32_t tag, uint64_t value, FlagsType<Flags::F>, Writer &out, bool force = false) 953 { 954 if (!force && value == UINT64_C(0)) 955 return; 956 957 SerialDetail::WriteTagWriteType(tag, WireType::FIXED64, out); 958 SerialDetail::WriteFixed(value, out); 959 } 960 961 static void SerializePacked(uint64_t value, FlagsType<>, Writer &out) 962 { 963 SerialDetail::WriteVarint(value, out); 964 } 965 966 static void SerializePacked(uint64_t value, FlagsType<Flags::F>, Writer &out) 967 { 968 SerialDetail::WriteFixed(value, out); 969 } 970 971 static bool Parse(WireType wire_type, uint64_t &value, FlagsType<>, Reader &in) 972 { 973 if (wire_type != WireType::VARINT) 974 return false; 975 return SerialDetail::ReadVarint(value, in); 976 } 977 978 static bool Parse(WireType wire_type, uint64_t &value, FlagsType<Flags::F>, Reader &in) 979 { 980 if (wire_type != WireType::FIXED64) 981 return false; 982 return SerialDetail::ReadFixed(value, in); 983 } 984 985 static bool ParsePacked(uint64_t &value, FlagsType<>, Reader &in) 986 { 987 return SerialDetail::ReadVarint(value, in); 988 } 989 990 static bool ParsePacked(uint64_t &value, FlagsType<Flags::F>, Reader &in) 991 { 992 return SerialDetail::ReadFixed(value, in); 993 } 994 }; 995 996 template<> struct Serializer<double> { 997 static void Serialize(uint32_t tag, double value, FlagsType<>, Writer &out, bool force = false) 998 { 999 if (!force && std::fpclassify(value) == FP_ZERO) { 1000 return; 1001 } 1002 SerialDetail::WriteTagWriteType(tag, WireType::FIXED64, out); 1003 SerialDetail::WriteFixed(value, out); 1004 } 1005 1006 static void SerializePacked(double value, FlagsType<>, Writer &out) 1007 { 1008 SerialDetail::WriteFixed(value, out); 1009 } 1010 1011 static bool Parse(WireType wire_type, double &value, FlagsType<>, Reader &in) 1012 { 1013 if (wire_type != WireType::FIXED64) { 1014 return false; 1015 } 1016 return SerialDetail::ReadFixed(value, in); 1017 } 1018 1019 static bool ParsePacked(double &value, FlagsType<>, Reader &in) 1020 { 1021 return SerialDetail::ReadFixed(value, in); 1022 } 1023 }; 1024 1025 template<> struct Serializer<float> { 1026 static void Serialize(uint32_t tag, float value, FlagsType<>, Writer &out, bool force = false) 1027 { 1028 if (!force && std::fpclassify(value) == FP_ZERO) { 1029 return; 1030 } 1031 SerialDetail::WriteTagWriteType(tag, WireType::FIXED32, out); 1032 SerialDetail::WriteFixed(value, out); 1033 } 1034 1035 static void SerializePacked(float value, FlagsType<>, Writer &out) 1036 { 1037 SerialDetail::WriteFixed(value, out); 1038 } 1039 1040 static bool Parse(WireType wire_type, float &value, FlagsType<>, Reader &in) 1041 { 1042 if (wire_type != WireType::FIXED32) { 1043 return false; 1044 } 1045 return SerialDetail::ReadFixed(value, in); 1046 } 1047 1048 static bool ParsePacked(float &value, FlagsType<>, Reader &in) 1049 { 1050 return SerialDetail::ReadFixed(value, in); 1051 } 1052 }; 1053 1054 template<> struct Serializer<bool> { 1055 static void Serialize(uint32_t tag, bool value, FlagsType<>, Writer &out, bool force = false) 1056 { 1057 Serializer<uint32_t>::Serialize(tag, value ? 1 : 0, FlagsType(), out, force); 1058 } 1059 1060 static void SerializePacked(bool value, FlagsType<>, Writer &out) 1061 { 1062 Serializer<uint32_t>::SerializePacked(value ? 1 : 0, FlagsType(), out); 1063 } 1064 1065 static bool Parse(WireType wire_type, bool &value, FlagsType<>, Reader &in) 1066 { 1067 uint32_t intermedaite_value; 1068 if (Serializer<uint32_t>::Parse(wire_type, intermedaite_value, FlagsType<>(), in)) { 1069 value = static_cast<bool>(intermedaite_value); 1070 return true; 1071 } 1072 return false; 1073 } 1074 1075 static bool ParsePacked(bool &value, FlagsType<>, Reader &in) 1076 { 1077 uint32_t intermedaite_value; 1078 if (Serializer<uint32_t>::ParsePacked(intermedaite_value, FlagsType<>(), in)) { 1079 value = static_cast<bool>(intermedaite_value); 1080 return true; 1081 } 1082 return false; 1083 } 1084 }; 1085 1086 template<class T> struct Serializer<T, std::enable_if_t<std::is_enum_v<T>>> { 1087 using U = std::underlying_type_t<T>; 1088 1089 static void Serialize(uint32_t tag, T value, FlagsType<>, Writer &out, bool force = false) 1090 { 1091 Serializer<U>::Serialize(tag, static_cast<U>(value), FlagsType<>(), out, force); 1092 } 1093 1094 static void SerializePacked(T value, FlagsType<>, Writer &out) 1095 { 1096 Serializer<U>::SerializePacked(static_cast<U>(value), FlagsType<>(), out); 1097 } 1098 1099 static bool Parse(WireType wire_type, T &value, FlagsType<>, Reader &in) 1100 { 1101 U intermedaite_value; 1102 if (Serializer<U>::Parse(wire_type, intermedaite_value, FlagsType<>(), in)) { 1103 value = static_cast<T>(intermedaite_value); 1104 return true; 1105 } 1106 return false; 1107 } 1108 1109 static bool ParsePacked(T &value, FlagsType<>, Reader &in) 1110 { 1111 U intermedaite_value; 1112 if (Serializer<U>::ParsePacked(intermedaite_value, FlagsType<>(), in)) { 1113 value = static_cast<T>(intermedaite_value); 1114 return true; 1115 } 1116 return false; 1117 } 1118 }; 1119 1120 template<> struct Serializer<std::string> { 1121 static void Serialize(uint32_t tag, const std::string &value, FlagsType<>, Writer &out, bool force = false) 1122 { 1123 (void)force; 1124 SerialDetail::WriteTagWriteType(tag, WireType::LENGTH_DELIMETED, out); 1125 SerialDetail::WriteVarint(value.size(), out); 1126 out.Write(value.data(), value.size()); 1127 } 1128 1129 static bool Parse(WireType wire_type, std::string &value, FlagsType<>, Reader &in) 1130 { 1131 if (wire_type != WireType::LENGTH_DELIMETED) { 1132 return false; 1133 } 1134 size_t size; 1135 if (SerialDetail::ReadVarint(size, in)) { 1136 value.resize(size); 1137 if (in.Read(value.data(), size) == size) { 1138 return true; 1139 } 1140 } 1141 return false; 1142 } 1143 }; 1144 1145 template<class T> struct Serializer<std::vector<T>> { 1146 template<uint32_t Flags> 1147 static void Serialize(uint32_t tag, const std::vector<T> &value, FlagsType<Flags>, Writer &out) 1148 { 1149 SerialDetail::WriteRepeated<Flags, T>(tag, value.begin(), value.end(), out); 1150 } 1151 1152 template<uint32_t Flags> 1153 static bool Parse(WireType wire_type, std::vector<T> &value, FlagsType<Flags>, Reader &in) 1154 { 1155 return SerialDetail::ReadRepeated<Flags, T>(wire_type, std::back_inserter(value), in); 1156 } 1157 }; 1158 1159 template<class T> struct Serializer<std::optional<T>> { 1160 template<uint32_t Flags> 1161 static void Serialize(uint32_t tag, const std::optional<T> &value, FlagsType<Flags>, Writer &out) 1162 { 1163 if (!value.has_value()) { 1164 return; 1165 } 1166 Serializer<T>::Serialize(tag, *value, FlagsType<Flags>(), out); 1167 } 1168 1169 template<uint32_t Flags> 1170 static bool Parse(WireType wire_type, std::optional<T> &value, FlagsType<Flags>, Reader &in) 1171 { 1172 return Serializer<T>::Parse(wire_type, value.emplace(), FlagsType<Flags>(), in); 1173 } 1174 }; 1175 1176 template<class... T> struct Serializer<std::variant<T...>> { 1177 template<size_t Index, uint32_t Flags> 1178 static void SerializeOneof(uint32_t tag, const std::variant<T...> &value, FlagsType<Flags>, Writer &out) 1179 { 1180 if (value.index() != Index) 1181 return; 1182 1183 Serializer<std::variant_alternative_t<Index, std::variant<T...>>>::Serialize( 1184 tag, std::get<Index>(value), FlagsType<Flags>(), out); 1185 } 1186 1187 template<size_t Index, uint32_t Flags> 1188 static bool ParseOneof(WireType wire_type, std::variant<T...> &value, FlagsType<Flags>, Reader &in) 1189 { 1190 return Serializer<std::variant_alternative_t<Index, std::variant<T...>>>::Parse( 1191 wire_type, value.template emplace<Index>(), FlagsType<Flags>(), in); 1192 } 1193 }; 1194 1195 template<class Key, class Value> struct Serializer<std::map<Key, Value>> { 1196 template<uint32_t KeyFlags, uint32_t ValueFlags> 1197 static void SerializeMap( 1198 uint32_t tag, const std::map<Key, Value> &value, FlagsType<KeyFlags>, FlagsType<ValueFlags>, Writer &out) 1199 { 1200 SerialDetail::WriteMap<KeyFlags, ValueFlags>(tag, value, out); 1201 } 1202 1203 template<uint32_t KeyFlags, uint32_t ValueFlags> 1204 static bool ParseMap( 1205 WireType wire_type, std::map<Key, Value> &value, FlagsType<KeyFlags>, FlagsType<ValueFlags>, Reader &in) 1206 { 1207 return SerialDetail::ReadMap<KeyFlags, ValueFlags>(wire_type, value, in); 1208 } 1209 }; 1210 1211 struct StringWriter : public Writer { 1212 StringWriter(std::string &out) 1213 : _out(out) 1214 { 1215 } 1216 1217 void Write(const void *bytes, size_t size) override 1218 { 1219 _out.append(reinterpret_cast<const char *>(bytes), size); 1220 } 1221 1222 private: 1223 std::string &_out; 1224 }; 1225 1226 struct StringReader : public Reader { 1227 StringReader(const std::string &in) 1228 : _in(in), _pos(0) 1229 { 1230 } 1231 1232 size_t Read(void *bytes, size_t size) override 1233 { 1234 size_t readSize = std::min(size, _in.size() - _pos); 1235 if (memcpy_s(bytes, size, _in.data() + _pos, readSize) != EOK) { 1236 return readSize; 1237 } 1238 _pos += readSize; 1239 return readSize; 1240 } 1241 1242 private: 1243 const std::string &_in; 1244 size_t _pos; 1245 }; 1246 // mytype begin, just support base type, but really use protobuf raw type(uint32) 1247 template<> struct Serializer<uint8_t> { 1248 static void Serialize(uint32_t tag, uint8_t value, FlagsType<>, Writer &out, bool force = false) 1249 { 1250 Serializer<uint32_t>::Serialize(tag, value, FlagsType(), out, force); 1251 } 1252 1253 static void SerializePacked(uint8_t value, FlagsType<>, Writer &out) 1254 { 1255 Serializer<uint32_t>::SerializePacked(value, FlagsType(), out); 1256 } 1257 1258 static bool Parse(WireType wire_type, uint8_t &value, FlagsType<>, Reader &in) 1259 { 1260 uint32_t intermedaite_value; 1261 if (Serializer<uint32_t>::Parse(wire_type, intermedaite_value, FlagsType<>(), in)) { 1262 value = static_cast<uint8_t>(intermedaite_value); 1263 return true; 1264 } 1265 return false; 1266 } 1267 1268 static bool ParsePacked(uint8_t &value, FlagsType<>, Reader &in) 1269 { 1270 uint32_t intermedaite_value; 1271 if (Serializer<uint32_t>::ParsePacked(intermedaite_value, FlagsType<>(), in)) { 1272 value = static_cast<uint8_t>(intermedaite_value); 1273 return true; 1274 } 1275 return false; 1276 } 1277 }; 1278 template<> struct Serializer<uint16_t> { 1279 static void Serialize(uint32_t tag, uint16_t value, FlagsType<>, Writer &out, bool force = false) 1280 { 1281 Serializer<uint32_t>::Serialize(tag, value, FlagsType(), out, force); 1282 } 1283 1284 static void SerializePacked(uint16_t value, FlagsType<>, Writer &out) 1285 { 1286 Serializer<uint32_t>::SerializePacked(value, FlagsType(), out); 1287 } 1288 1289 static bool Parse(WireType wire_type, uint16_t &value, FlagsType<>, Reader &in) 1290 { 1291 uint32_t intermedaite_value; 1292 if (Serializer<uint32_t>::Parse(wire_type, intermedaite_value, FlagsType<>(), in)) { 1293 value = static_cast<uint16_t>(intermedaite_value); 1294 return true; 1295 } 1296 return false; 1297 } 1298 1299 static bool ParsePacked(uint16_t &value, FlagsType<>, Reader &in) 1300 { 1301 uint32_t intermedaite_value; 1302 if (Serializer<uint32_t>::ParsePacked(intermedaite_value, FlagsType<>(), in)) { 1303 value = static_cast<uint16_t>(intermedaite_value); 1304 return true; 1305 } 1306 return false; 1307 } 1308 }; 1309 // mytype finish 1310 1311 template<class T> std::string SerializeToString(const T &value) 1312 { 1313 std::string out; 1314 StringWriter stringOut(out); 1315 SerialDetail::WriteMessage(value, MessageType<T>(), stringOut); 1316 return out; 1317 } 1318 1319 template<class T> bool ParseFromString(T &value, const std::string &in) 1320 { 1321 StringReader stringIn(in); 1322 return SerialDetail::ReadMessage(value, MessageType<T>(), stringIn); 1323 } 1324 } 1325 // clang-format on 1326 } // Hdc 1327 #endif // HDC_SERIAL_STRUCT_DEFINE_H 1328