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); // 3:tag type offset 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; // 3:tag type offset 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); //31:uint32_t val offset 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); // 63:uint32_t val offset 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 constexpr uint8_t bytesSize = 5; 286 constexpr uint8_t bytesOffset = 7; 287 uint8_t b[bytesSize] {}; 288 for (size_t i = 0; i < bytesSize; ++i) { 289 b[i] = value & 0b0111'1111; 290 value >>= bytesOffset; 291 if (value) { 292 b[i] |= 0b1000'0000; 293 } else { 294 out.Write(b, i + 1); 295 break; 296 } 297 } 298 } 299 300 static void WriteVarint(uint64_t value, Writer &out) 301 { 302 constexpr uint8_t bytesSize = 10; 303 constexpr uint8_t bytesOffset = 7; 304 uint8_t b[bytesSize] {}; 305 for (size_t i = 0; i < bytesSize; ++i) { 306 b[i] = value & 0b0111'1111; 307 value >>= bytesOffset; 308 if (value) { 309 b[i] |= 0b1000'0000; 310 } else { 311 out.Write(b, i + 1); 312 break; 313 } 314 } 315 } 316 317 #if defined(HOST_MAC) 318 static void WriteVarint(unsigned long value, Writer &out) 319 { 320 WriteVarint(static_cast<uint64_t>(value), out); 321 } 322 #endif 323 324 static bool ReadVarint(uint32_t &value, Reader &in) 325 { 326 value = 0; 327 constexpr uint8_t bytesSize = 5; 328 constexpr uint8_t bytesOffset = 7; 329 for (size_t c = 0; c < bytesSize; ++c) { 330 uint8_t x; 331 if (!ReadByte(x, in)) { 332 return false; 333 } 334 value |= static_cast<uint32_t>(x & 0b0111'1111) << bytesOffset * c; 335 if (!(x & 0b1000'0000)) { 336 return true; 337 } 338 } 339 340 return false; 341 } 342 343 static bool ReadVarint(uint64_t &value, Reader &in) 344 { 345 value = 0; 346 constexpr uint8_t bytesSize = 10; 347 constexpr uint8_t bytesOffset = 7; 348 for (size_t c = 0; c < bytesSize; ++c) { 349 uint8_t x; 350 if (!ReadByte(x, in)) { 351 return false; 352 } 353 value |= static_cast<uint64_t>(x & 0b0111'1111) << bytesOffset * c; 354 if (!(x & 0b1000'0000)) { 355 return true; 356 } 357 } 358 return false; 359 } 360 361 #if defined(HOST_MAC) 362 static bool ReadVarint(unsigned long &value, Reader &in) 363 { 364 uint64_t intermediateValue; 365 if (ReadVarint(intermediateValue, in)) { 366 value = static_cast<unsigned long>(intermediateValue); 367 return true; 368 } 369 return false; 370 } 371 #endif 372 373 static void WriteFixed(uint32_t value, Writer &out) 374 { 375 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 376 out.Write(&value, sizeof(value)); 377 #else 378 static_assert(false, "Not a little-endian"); 379 #endif 380 } 381 382 static void WriteFixed(uint64_t value, Writer &out) 383 { 384 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 385 out.Write(&value, sizeof(value)); 386 #else 387 static_assert(false, "Not a little-endian"); 388 #endif 389 } 390 391 static void WriteFixed(double value, Writer &out) 392 { 393 WriteFixed(BitCast<uint64_t>(value), out); 394 } 395 396 static void WriteFixed(float value, Writer &out) 397 { 398 WriteFixed(BitCast<uint32_t>(value), out); 399 } 400 401 static void WriteVarint(int32_t value, Writer &out) 402 { 403 WriteVarint(BitCast<uint32_t>(value), out); 404 } 405 406 static void WriteVarint(int64_t value, Writer &out) 407 { 408 WriteVarint(BitCast<uint64_t>(value), out); 409 } 410 411 static void WriteSignedVarint(int32_t value, Writer &out) 412 { 413 WriteVarint(MakeZigzagValue(value), out); 414 } 415 416 static void WriteSignedVarint(int64_t value, Writer &out) 417 { 418 WriteVarint(MakeZigzagValue(value), out); 419 } 420 421 static void WriteSignedFixed(int32_t value, Writer &out) 422 { 423 WriteFixed(static_cast<uint32_t>(value), out); 424 } 425 426 static void WriteSignedFixed(int64_t value, Writer &out) 427 { 428 WriteFixed(static_cast<uint64_t>(value), out); 429 } 430 431 static void WriteTagWriteType(uint32_t tag, WireType wireType, Writer &out) 432 { 433 WriteVarint(MakeTagWireType(tag, wireType), out); 434 } 435 436 static bool ReadFixed(uint32_t &value, Reader &in) 437 { 438 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 439 return in.Read(&value, sizeof(value)) == sizeof(value); 440 #else 441 static_assert(false, "Not a little-endian"); 442 #endif 443 } 444 445 static bool ReadFixed(uint64_t &value, Reader &in) 446 { 447 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 448 return in.Read(&value, sizeof(value)) == sizeof(value); 449 #else 450 static_assert(false, "Not a little-endian"); 451 #endif 452 } 453 454 static bool ReadFixed(double &value, Reader &in) 455 { 456 uint64_t intermediateValue; 457 if (ReadFixed(intermediateValue, in)) { 458 value = BitCast<double>(intermediateValue); 459 return true; 460 } 461 return false; 462 } 463 464 static bool ReadFixed(float &value, Reader &in) 465 { 466 uint32_t intermediateValue; 467 if (ReadFixed(intermediateValue, in)) { 468 value = BitCast<float>(intermediateValue); 469 return true; 470 } 471 return false; 472 } 473 474 static bool ReadVarint(int32_t &value, Reader &in) 475 { 476 uint32_t intermediateValue; 477 if (ReadVarint(intermediateValue, in)) { 478 value = BitCast<int32_t>(intermediateValue); 479 return true; 480 } 481 return false; 482 } 483 484 static bool ReadVarint(int64_t &value, Reader &in) 485 { 486 uint64_t intermediateValue; 487 if (ReadVarint(intermediateValue, in)) { 488 value = BitCast<int64_t>(intermediateValue); 489 return true; 490 } 491 return false; 492 } 493 494 static bool ReadSignedVarint(int32_t &value, Reader &in) 495 { 496 uint32_t intermediateValue; 497 if (ReadVarint(intermediateValue, in)) { 498 value = ReadZigzagValue(intermediateValue); 499 return true; 500 } 501 return false; 502 } 503 504 static bool ReadSignedVarint(int64_t &value, Reader &in) 505 { 506 uint64_t intermediateValue; 507 if (ReadVarint(intermediateValue, in)) { 508 value = ReadZigzagValue(intermediateValue); 509 return true; 510 } 511 return false; 512 } 513 514 static bool ReadSignedFixed(int32_t &value, Reader &in) 515 { 516 uint32_t intermediateValue; 517 if (ReadFixed(intermediateValue, in)) { 518 value = static_cast<int64_t>(intermediateValue); 519 return true; 520 } 521 return false; 522 } 523 524 static bool ReadSignedFixed(int64_t &value, Reader &in) 525 { 526 uint64_t intermediateValue; 527 if (ReadFixed(intermediateValue, in)) { 528 value = static_cast<int64_t>(intermediateValue); 529 return true; 530 } 531 return false; 532 } 533 534 template<class T, uint32_t Tag, size_t Index, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> 535 void WriteField(const T &value, 536 const SerialDetail::OneofFieldImpl<Tag, Index, MemPtrT, MemPtr, Flags> &, Writer &out) 537 { 538 using OneOf = SerialDetail::OneofFieldImpl<Tag, Index, MemPtrT, MemPtr, Flags>; 539 Serializer<typename OneOf::MemberType>::template SerializeOneof<OneOf::INDEX>( 540 OneOf::TAG, OneOf::get(value), FlagsType<OneOf::FLAGS>(), out); 541 } 542 543 template<class T, uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t KeyFlags, uint32_t ValueFlags> 544 void WriteField(const T &value, 545 const SerialDetail::MapFieldImpl<Tag, MemPtrT, MemPtr, KeyFlags, ValueFlags> &, Writer &out) 546 { 547 using Map = SerialDetail::MapFieldImpl<Tag, MemPtrT, MemPtr, KeyFlags, ValueFlags>; 548 Serializer<typename Map::MemberType>::SerializeMap( 549 Map::TAG, Map::get(value), FlagsType<Map::KEY_FLAGS>(), FlagsType<Map::VALUE_FLAGS>(), out); 550 } 551 552 template<class T, uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> 553 void WriteField(const T &value, const SerialDetail::FieldImpl<Tag, MemPtrT, MemPtr, Flags> &, Writer &out) 554 { 555 using Field = SerialDetail::FieldImpl<Tag, MemPtrT, MemPtr, Flags>; 556 Serializer<typename Field::MemberType>::Serialize( 557 Field::TAG, Field::get(value), FlagsType<Field::FLAGS>(), out); 558 } 559 560 template<class T, class... Field> 561 void WriteMessage(const T &value, const SerialDetail::MessageImpl<Field...> &message, Writer &out) 562 { 563 message.Visit([&](const auto &field) { WriteField(value, field, out); }); 564 } 565 566 template<uint32_t Flags, class ValueType, class It> 567 void WriteRepeated(uint32_t tag, It begin, It end, Writer &out) 568 { 569 if (begin == end) { 570 return; 571 } 572 if constexpr (SerialDetail::HAS_SERIALIZE_PACKED_V<Serializer<ValueType>, ValueType, FlagsType<Flags>, 573 Writer>) { 574 WriteVarint(MakeTagWireType(tag, WireType::LENGTH_DELIMETED), out); 575 WriterSizeCollector sizeCollector; 576 for (auto it = begin; it != end; ++it) { 577 Serializer<ValueType>::SerializePacked(*it, FlagsType<Flags> {}, sizeCollector); 578 } 579 WriteVarint(sizeCollector.byte_size, out); 580 for (auto it = begin; it != end; ++it) { 581 Serializer<ValueType>::SerializePacked(*it, FlagsType<Flags> {}, out); 582 } 583 } else { 584 for (auto it = begin; it != end; ++it) { 585 Serializer<ValueType>::Serialize(tag, *it, FlagsType<Flags>(), out); 586 } 587 } 588 } 589 590 template<uint32_t KeyFlags, uint32_t ValueFlags, class Key, class Value> 591 void WriteMapKeyValue(const std::pair<const Key, Value> &value, Writer &out) 592 { 593 Serializer<Key>::Serialize(1, value.first, FlagsType<KeyFlags> {}, out, true); 594 Serializer<Value>::Serialize(2, value.second, FlagsType<ValueFlags> {}, out, true); // 2:tag value 595 } 596 597 template<uint32_t KeyFlags, uint32_t ValueFlags, class T> 598 void WriteMap(uint32_t tag, const T &value, Writer &out) 599 { 600 auto begin = std::begin(value); 601 auto end = std::end(value); 602 603 for (auto it = begin; it != end; ++it) { 604 WriteTagWriteType(tag, WireType::LENGTH_DELIMETED, out); 605 WriterSizeCollector sizeCollector; 606 WriteMapKeyValue<KeyFlags, ValueFlags>(*it, sizeCollector); 607 WriteVarint(sizeCollector.byte_size, out); 608 WriteMapKeyValue<KeyFlags, ValueFlags>(*it, out); 609 } 610 } 611 612 template<uint32_t KeyFlags, uint32_t ValueFlags, class Key, class Value> 613 bool ReadMapKeyValue(std::pair<Key, Value> &value, Reader &in) 614 { 615 static const auto pairAsMessage = Message(Field<1, &std::pair<Key, Value>::first, KeyFlags>("key"), 616 Field<2, &std::pair<Key, Value>::second, ValueFlags>("value")); 617 return ReadMessage(value, pairAsMessage, in); 618 } 619 620 template<uint32_t KeyFlags, uint32_t ValueFlags, class T> 621 bool ReadMap(WireType wireType, T &value, Reader &in) 622 { 623 if (wireType != WireType::LENGTH_DELIMETED) { 624 return false; 625 } 626 size_t size; 627 if (ReadVarint(size, in)) { 628 LimitedReader limitedIn(in, size); 629 while (limitedIn.AvailableBytes() > 0) { 630 std::pair<typename T::key_type, typename T::mapped_type> item; 631 if (!ReadMapKeyValue<KeyFlags, ValueFlags>(item, limitedIn)) { 632 return false; 633 } 634 value.insert(std::move(item)); 635 } 636 return true; 637 } 638 return false; 639 } 640 641 template<uint32_t Flags, class ValueType, class OutputIt> 642 bool ReadRepeated(WireType wireType, OutputIt output_it, Reader &in) 643 { 644 if constexpr (SerialDetail::HAS_PARSE_PACKED_V<Serializer<ValueType>, ValueType, FlagsType<Flags>, 645 Reader>) { 646 if (wireType != WireType::LENGTH_DELIMETED) { 647 return false; 648 } 649 650 size_t size; 651 if (ReadVarint(size, in)) { 652 LimitedReader limitedIn(in, size); 653 654 while (limitedIn.AvailableBytes() > 0) { 655 ValueType value; 656 if (!Serializer<ValueType>::ParsePacked(value, FlagsType<Flags>(), limitedIn)) { 657 return false; 658 } 659 output_it = value; 660 ++output_it; 661 } 662 return true; 663 } 664 return false; 665 } else { 666 ValueType value; 667 if (Serializer<ValueType>::Parse(wireType, value, FlagsType<Flags>(), in)) { 668 output_it = value; 669 ++output_it; 670 return true; 671 } 672 return false; 673 } 674 } 675 676 template<class T, uint32_t Tag, size_t Index, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> 677 void ReadField(T &value, uint32_t tag, WireType wireType, 678 const SerialDetail::OneofFieldImpl<Tag, Index, MemPtrT, MemPtr, Flags> &, Reader &in) 679 { 680 if (Tag != tag) { 681 return; 682 } 683 using OneOf = SerialDetail::OneofFieldImpl<Tag, Index, MemPtrT, MemPtr, Flags>; 684 Serializer<typename OneOf::MemberType>::template ParseOneof<OneOf::INDEX>( 685 wireType, OneOf::get(value), FlagsType<OneOf::FLAGS>(), in); 686 } 687 688 template<class T, uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t KeyFlags, uint32_t ValueFlags> 689 void ReadField(T &value, uint32_t tag, WireType wireType, 690 const SerialDetail::MapFieldImpl<Tag, MemPtrT, MemPtr, KeyFlags, ValueFlags> &, Reader &in) 691 { 692 if (Tag != tag) { 693 return; 694 } 695 using Map = SerialDetail::MapFieldImpl<Tag, MemPtrT, MemPtr, KeyFlags, ValueFlags>; 696 Serializer<typename Map::MemberType>::ParseMap( 697 wireType, Map::get(value), FlagsType<Map::KEY_FLAGS>(), FlagsType<Map::VALUE_FLAGS>(), in); 698 } 699 700 template<class T, uint32_t Tag, class MemPtrT, MemPtrT MemPtr, uint32_t Flags> 701 void ReadField(T &value, uint32_t tag, WireType wireType, 702 const SerialDetail::FieldImpl<Tag, MemPtrT, MemPtr, Flags> &, Reader &in) 703 { 704 if (Tag != tag) { 705 return; 706 } 707 using Field = SerialDetail::FieldImpl<Tag, MemPtrT, MemPtr, Flags>; 708 Serializer<typename Field::MemberType>::Parse(wireType, Field::get(value), FlagsType<Field::FLAGS>(), in); 709 } 710 711 template<class T, class... Field> bool ReadMessage(T &value, const MessageImpl<Field...> &message, Reader &in) 712 { 713 uint32_t tagKey; 714 while (ReadVarint(tagKey, in)) { 715 uint32_t tag; 716 WireType wireType; 717 ReadTagWireType(tagKey, tag, wireType); 718 message.Visit([&](const auto &field) { ReadField(value, tag, wireType, field, in); }); 719 } 720 return true; 721 } 722 } 723 724 template<class T, class Enable> struct Serializer { 725 // Commion Serializer threat type as Message 726 static void Serialize(uint32_t tag, const T &value, FlagsType<>, Writer &out, bool force = false) 727 { 728 SerialDetail::WriterSizeCollector sizeCollector; 729 SerialDetail::WriteMessage(value, MessageType<T>(), sizeCollector); 730 if (!force && sizeCollector.byte_size == 0) { 731 return; 732 } 733 SerialDetail::WriteTagWriteType(tag, WireType::LENGTH_DELIMETED, out); 734 SerialDetail::WriteVarint(sizeCollector.byte_size, out); 735 SerialDetail::WriteMessage(value, MessageType<T>(), out); 736 } 737 738 static bool Parse(WireType wireType, T &value, FlagsType<>, Reader &in) 739 { 740 if (wireType != WireType::LENGTH_DELIMETED) { 741 return false; 742 } 743 size_t size; 744 if (SerialDetail::ReadVarint(size, in)) { 745 SerialDetail::LimitedReader limitedIn(in, size); 746 return SerialDetail::ReadMessage(value, MessageType<T>(), limitedIn); 747 } 748 return false; 749 } 750 }; 751 752 template<> struct Serializer<int32_t> { 753 static void Serialize(uint32_t tag, int32_t value, FlagsType<>, Writer &out, bool force = false) 754 { 755 (void)force; 756 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 757 SerialDetail::WriteVarint(value, out); 758 } 759 760 static void Serialize(uint32_t tag, int32_t value, FlagsType<Flags::S>, Writer &out, bool force = false) 761 { 762 (void)force; 763 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 764 SerialDetail::WriteSignedVarint(value, out); 765 } 766 767 static void Serialize( 768 uint32_t tag, int32_t value, FlagsType<Flags::S | Flags::F>, Writer &out, bool force = false) 769 { 770 (void)force; 771 SerialDetail::WriteTagWriteType(tag, WireType::FIXED32, out); 772 SerialDetail::WriteSignedFixed(value, out); 773 } 774 775 static void SerializePacked(int32_t value, FlagsType<>, Writer &out) 776 { 777 SerialDetail::WriteVarint(value, out); 778 } 779 780 static void SerializePacked(int32_t value, FlagsType<Flags::S>, Writer &out) 781 { 782 SerialDetail::WriteSignedVarint(value, out); 783 } 784 785 static void SerializePacked(int32_t value, FlagsType<Flags::S | Flags::F>, Writer &out) 786 { 787 SerialDetail::WriteSignedFixed(value, out); 788 } 789 790 static bool Parse(WireType wire_type, int32_t &value, FlagsType<>, Reader &in) 791 { 792 if (wire_type != WireType::VARINT) 793 return false; 794 return SerialDetail::ReadVarint(value, in); 795 } 796 797 static bool Parse(WireType wire_type, int32_t &value, FlagsType<Flags::S>, Reader &in) 798 { 799 if (wire_type != WireType::VARINT) 800 return false; 801 return SerialDetail::ReadSignedVarint(value, in); 802 } 803 804 static bool Parse(WireType wire_type, int32_t &value, FlagsType<Flags::S | Flags::F>, Reader &in) 805 { 806 if (wire_type != WireType::FIXED32) 807 return false; 808 return SerialDetail::ReadSignedFixed(value, in); 809 } 810 811 static bool ParsePacked(int32_t &value, FlagsType<>, Reader &in) 812 { 813 return SerialDetail::ReadVarint(value, in); 814 } 815 816 static bool ParsePacked(int32_t &value, FlagsType<Flags::S>, Reader &in) 817 { 818 return SerialDetail::ReadSignedVarint(value, in); 819 } 820 821 static bool ParsePacked(int32_t &value, FlagsType<Flags::S | Flags::F>, Reader &in) 822 { 823 return SerialDetail::ReadSignedFixed(value, in); 824 } 825 }; 826 827 template<> struct Serializer<uint32_t> { 828 static void Serialize(uint32_t tag, uint32_t value, FlagsType<>, Writer &out, bool force = false) 829 { 830 (void)force; 831 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 832 SerialDetail::WriteVarint(value, out); 833 } 834 835 static void Serialize(uint32_t tag, uint32_t value, FlagsType<Flags::F>, Writer &out, bool force = false) 836 { 837 (void)force; 838 SerialDetail::WriteTagWriteType(tag, WireType::FIXED32, out); 839 SerialDetail::WriteFixed(value, out); 840 } 841 842 static void SerializePacked(uint32_t value, FlagsType<>, Writer &out) 843 { 844 SerialDetail::WriteVarint(value, out); 845 } 846 847 static void SerializePacked(uint32_t value, FlagsType<Flags::F>, Writer &out) 848 { 849 SerialDetail::WriteFixed(value, out); 850 } 851 852 static bool Parse(WireType wire_type, uint32_t &value, FlagsType<>, Reader &in) 853 { 854 if (wire_type != WireType::VARINT) 855 return false; 856 return SerialDetail::ReadVarint(value, in); 857 } 858 859 static bool Parse(WireType wire_type, uint32_t &value, FlagsType<Flags::F>, Reader &in) 860 { 861 if (wire_type != WireType::FIXED32) 862 return false; 863 return SerialDetail::ReadFixed(value, in); 864 } 865 866 static bool ParsePacked(uint32_t &value, FlagsType<>, Reader &in) 867 { 868 return SerialDetail::ReadVarint(value, in); 869 } 870 871 static bool ParsePacked(uint32_t &value, FlagsType<Flags::F>, Reader &in) 872 { 873 return SerialDetail::ReadFixed(value, in); 874 } 875 }; 876 877 template<> struct Serializer<int64_t> { 878 static void Serialize(uint32_t tag, int64_t value, FlagsType<>, Writer &out, bool force = false) 879 { 880 (void)force; 881 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 882 SerialDetail::WriteVarint(value, out); 883 } 884 885 static void Serialize(uint32_t tag, int64_t value, FlagsType<Flags::S>, Writer &out, bool force = false) 886 { 887 (void)force; 888 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 889 SerialDetail::WriteSignedVarint(value, out); 890 } 891 892 static void Serialize( 893 uint32_t tag, int64_t value, FlagsType<Flags::S | Flags::F>, Writer &out, bool force = false) 894 { 895 (void)force; 896 SerialDetail::WriteTagWriteType(tag, WireType::FIXED64, out); 897 SerialDetail::WriteSignedFixed(value, out); 898 } 899 900 static void SerializePacked(int64_t value, FlagsType<>, Writer &out) 901 { 902 SerialDetail::WriteVarint(value, out); 903 } 904 905 static void SerializePacked(int64_t value, FlagsType<Flags::S>, Writer &out) 906 { 907 SerialDetail::WriteSignedVarint(value, out); 908 } 909 910 static void SerializePacked(int64_t value, FlagsType<Flags::S | Flags::F>, Writer &out) 911 { 912 SerialDetail::WriteSignedFixed(value, out); 913 } 914 915 static bool Parse(WireType wire_type, int64_t &value, FlagsType<>, Reader &in) 916 { 917 if (wire_type != WireType::VARINT) 918 return false; 919 return SerialDetail::ReadVarint(value, in); 920 } 921 922 static bool Parse(WireType wire_type, int64_t &value, FlagsType<Flags::S>, Reader &in) 923 { 924 if (wire_type != WireType::VARINT) 925 return false; 926 return SerialDetail::ReadSignedVarint(value, in); 927 } 928 929 static bool Parse(WireType wire_type, int64_t &value, FlagsType<Flags::S | Flags::F>, Reader &in) 930 { 931 if (wire_type != WireType::FIXED64) 932 return false; 933 return SerialDetail::ReadSignedFixed(value, in); 934 } 935 936 static bool ParsePacked(int64_t &value, FlagsType<>, Reader &in) 937 { 938 return SerialDetail::ReadVarint(value, in); 939 } 940 941 static bool ParsePacked(int64_t &value, FlagsType<Flags::S>, Reader &in) 942 { 943 return SerialDetail::ReadSignedVarint(value, in); 944 } 945 946 static bool ParsePacked(int64_t &value, FlagsType<Flags::S | Flags::F>, Reader &in) 947 { 948 return SerialDetail::ReadSignedFixed(value, in); 949 } 950 }; 951 952 template<> struct Serializer<uint64_t> { 953 static void Serialize(uint32_t tag, uint64_t value, FlagsType<>, Writer &out, bool force = false) 954 { 955 (void)force; 956 SerialDetail::WriteTagWriteType(tag, WireType::VARINT, out); 957 SerialDetail::WriteVarint(value, out); 958 } 959 960 static void Serialize(uint32_t tag, uint64_t value, FlagsType<Flags::F>, Writer &out, bool force = false) 961 { 962 if (!force && value == UINT64_C(0)) 963 return; 964 965 SerialDetail::WriteTagWriteType(tag, WireType::FIXED64, out); 966 SerialDetail::WriteFixed(value, out); 967 } 968 969 static void SerializePacked(uint64_t value, FlagsType<>, Writer &out) 970 { 971 SerialDetail::WriteVarint(value, out); 972 } 973 974 static void SerializePacked(uint64_t value, FlagsType<Flags::F>, Writer &out) 975 { 976 SerialDetail::WriteFixed(value, out); 977 } 978 979 static bool Parse(WireType wire_type, uint64_t &value, FlagsType<>, Reader &in) 980 { 981 if (wire_type != WireType::VARINT) 982 return false; 983 return SerialDetail::ReadVarint(value, in); 984 } 985 986 static bool Parse(WireType wire_type, uint64_t &value, FlagsType<Flags::F>, Reader &in) 987 { 988 if (wire_type != WireType::FIXED64) 989 return false; 990 return SerialDetail::ReadFixed(value, in); 991 } 992 993 static bool ParsePacked(uint64_t &value, FlagsType<>, Reader &in) 994 { 995 return SerialDetail::ReadVarint(value, in); 996 } 997 998 static bool ParsePacked(uint64_t &value, FlagsType<Flags::F>, Reader &in) 999 { 1000 return SerialDetail::ReadFixed(value, in); 1001 } 1002 }; 1003 1004 template<> struct Serializer<double> { 1005 static void Serialize(uint32_t tag, double value, FlagsType<>, Writer &out, bool force = false) 1006 { 1007 if (!force && std::fpclassify(value) == FP_ZERO) { 1008 return; 1009 } 1010 SerialDetail::WriteTagWriteType(tag, WireType::FIXED64, out); 1011 SerialDetail::WriteFixed(value, out); 1012 } 1013 1014 static void SerializePacked(double value, FlagsType<>, Writer &out) 1015 { 1016 SerialDetail::WriteFixed(value, out); 1017 } 1018 1019 static bool Parse(WireType wire_type, double &value, FlagsType<>, Reader &in) 1020 { 1021 if (wire_type != WireType::FIXED64) { 1022 return false; 1023 } 1024 return SerialDetail::ReadFixed(value, in); 1025 } 1026 1027 static bool ParsePacked(double &value, FlagsType<>, Reader &in) 1028 { 1029 return SerialDetail::ReadFixed(value, in); 1030 } 1031 }; 1032 1033 template<> struct Serializer<float> { 1034 static void Serialize(uint32_t tag, float value, FlagsType<>, Writer &out, bool force = false) 1035 { 1036 if (!force && std::fpclassify(value) == FP_ZERO) { 1037 return; 1038 } 1039 SerialDetail::WriteTagWriteType(tag, WireType::FIXED32, out); 1040 SerialDetail::WriteFixed(value, out); 1041 } 1042 1043 static void SerializePacked(float value, FlagsType<>, Writer &out) 1044 { 1045 SerialDetail::WriteFixed(value, out); 1046 } 1047 1048 static bool Parse(WireType wire_type, float &value, FlagsType<>, Reader &in) 1049 { 1050 if (wire_type != WireType::FIXED32) { 1051 return false; 1052 } 1053 return SerialDetail::ReadFixed(value, in); 1054 } 1055 1056 static bool ParsePacked(float &value, FlagsType<>, Reader &in) 1057 { 1058 return SerialDetail::ReadFixed(value, in); 1059 } 1060 }; 1061 1062 template<> struct Serializer<bool> { 1063 static void Serialize(uint32_t tag, bool value, FlagsType<>, Writer &out, bool force = false) 1064 { 1065 Serializer<uint32_t>::Serialize(tag, value ? 1 : 0, FlagsType(), out, force); 1066 } 1067 1068 static void SerializePacked(bool value, FlagsType<>, Writer &out) 1069 { 1070 Serializer<uint32_t>::SerializePacked(value ? 1 : 0, FlagsType(), out); 1071 } 1072 1073 static bool Parse(WireType wire_type, bool &value, FlagsType<>, Reader &in) 1074 { 1075 uint32_t intermedaite_value; 1076 if (Serializer<uint32_t>::Parse(wire_type, intermedaite_value, FlagsType<>(), in)) { 1077 value = static_cast<bool>(intermedaite_value); 1078 return true; 1079 } 1080 return false; 1081 } 1082 1083 static bool ParsePacked(bool &value, FlagsType<>, Reader &in) 1084 { 1085 uint32_t intermedaite_value; 1086 if (Serializer<uint32_t>::ParsePacked(intermedaite_value, FlagsType<>(), in)) { 1087 value = static_cast<bool>(intermedaite_value); 1088 return true; 1089 } 1090 return false; 1091 } 1092 }; 1093 1094 template<class T> struct Serializer<T, std::enable_if_t<std::is_enum_v<T>>> { 1095 using U = std::underlying_type_t<T>; 1096 1097 static void Serialize(uint32_t tag, T value, FlagsType<>, Writer &out, bool force = false) 1098 { 1099 Serializer<U>::Serialize(tag, static_cast<U>(value), FlagsType<>(), out, force); 1100 } 1101 1102 static void SerializePacked(T value, FlagsType<>, Writer &out) 1103 { 1104 Serializer<U>::SerializePacked(static_cast<U>(value), FlagsType<>(), out); 1105 } 1106 1107 static bool Parse(WireType wire_type, T &value, FlagsType<>, Reader &in) 1108 { 1109 U intermedaite_value; 1110 if (Serializer<U>::Parse(wire_type, intermedaite_value, FlagsType<>(), in)) { 1111 value = static_cast<T>(intermedaite_value); 1112 return true; 1113 } 1114 return false; 1115 } 1116 1117 static bool ParsePacked(T &value, FlagsType<>, Reader &in) 1118 { 1119 U intermedaite_value; 1120 if (Serializer<U>::ParsePacked(intermedaite_value, FlagsType<>(), in)) { 1121 value = static_cast<T>(intermedaite_value); 1122 return true; 1123 } 1124 return false; 1125 } 1126 }; 1127 1128 template<> struct Serializer<std::string> { 1129 static void Serialize(uint32_t tag, const std::string &value, FlagsType<>, Writer &out, bool force = false) 1130 { 1131 (void)force; 1132 SerialDetail::WriteTagWriteType(tag, WireType::LENGTH_DELIMETED, out); 1133 SerialDetail::WriteVarint(value.size(), out); 1134 out.Write(value.data(), value.size()); 1135 } 1136 1137 static bool Parse(WireType wire_type, std::string &value, FlagsType<>, Reader &in) 1138 { 1139 if (wire_type != WireType::LENGTH_DELIMETED) { 1140 return false; 1141 } 1142 size_t size; 1143 if (SerialDetail::ReadVarint(size, in)) { 1144 value.resize(size); 1145 if (in.Read(value.data(), size) == size) { 1146 return true; 1147 } 1148 } 1149 return false; 1150 } 1151 }; 1152 1153 template<class T> struct Serializer<std::vector<T>> { 1154 template<uint32_t Flags> 1155 static void Serialize(uint32_t tag, const std::vector<T> &value, FlagsType<Flags>, Writer &out) 1156 { 1157 SerialDetail::WriteRepeated<Flags, T>(tag, value.begin(), value.end(), out); 1158 } 1159 1160 template<uint32_t Flags> 1161 static bool Parse(WireType wire_type, std::vector<T> &value, FlagsType<Flags>, Reader &in) 1162 { 1163 return SerialDetail::ReadRepeated<Flags, T>(wire_type, std::back_inserter(value), in); 1164 } 1165 }; 1166 1167 template<class T> struct Serializer<std::optional<T>> { 1168 template<uint32_t Flags> 1169 static void Serialize(uint32_t tag, const std::optional<T> &value, FlagsType<Flags>, Writer &out) 1170 { 1171 if (!value.has_value()) { 1172 return; 1173 } 1174 Serializer<T>::Serialize(tag, *value, FlagsType<Flags>(), out); 1175 } 1176 1177 template<uint32_t Flags> 1178 static bool Parse(WireType wire_type, std::optional<T> &value, FlagsType<Flags>, Reader &in) 1179 { 1180 return Serializer<T>::Parse(wire_type, value.emplace(), FlagsType<Flags>(), in); 1181 } 1182 }; 1183 1184 template<class... T> struct Serializer<std::variant<T...>> { 1185 template<size_t Index, uint32_t Flags> 1186 static void SerializeOneof(uint32_t tag, const std::variant<T...> &value, FlagsType<Flags>, Writer &out) 1187 { 1188 if (value.index() != Index) 1189 return; 1190 1191 Serializer<std::variant_alternative_t<Index, std::variant<T...>>>::Serialize( 1192 tag, std::get<Index>(value), FlagsType<Flags>(), out); 1193 } 1194 1195 template<size_t Index, uint32_t Flags> 1196 static bool ParseOneof(WireType wire_type, std::variant<T...> &value, FlagsType<Flags>, Reader &in) 1197 { 1198 return Serializer<std::variant_alternative_t<Index, std::variant<T...>>>::Parse( 1199 wire_type, value.template emplace<Index>(), FlagsType<Flags>(), in); 1200 } 1201 }; 1202 1203 template<class Key, class Value> struct Serializer<std::map<Key, Value>> { 1204 template<uint32_t KeyFlags, uint32_t ValueFlags> 1205 static void SerializeMap( 1206 uint32_t tag, const std::map<Key, Value> &value, FlagsType<KeyFlags>, FlagsType<ValueFlags>, Writer &out) 1207 { 1208 SerialDetail::WriteMap<KeyFlags, ValueFlags>(tag, value, out); 1209 } 1210 1211 template<uint32_t KeyFlags, uint32_t ValueFlags> 1212 static bool ParseMap( 1213 WireType wire_type, std::map<Key, Value> &value, FlagsType<KeyFlags>, FlagsType<ValueFlags>, Reader &in) 1214 { 1215 return SerialDetail::ReadMap<KeyFlags, ValueFlags>(wire_type, value, in); 1216 } 1217 }; 1218 1219 struct StringWriter : public Writer { 1220 StringWriter(std::string &out) 1221 : _out(out) 1222 { 1223 } 1224 1225 void Write(const void *bytes, size_t size) override 1226 { 1227 _out.append(reinterpret_cast<const char *>(bytes), size); 1228 } 1229 1230 private: 1231 std::string &_out; 1232 }; 1233 1234 struct StringReader : public Reader { 1235 StringReader(const std::string &in) 1236 : _in(in), _pos(0) 1237 { 1238 } 1239 1240 size_t Read(void *bytes, size_t size) override 1241 { 1242 size_t readSize = std::min(size, _in.size() - _pos); 1243 if (memcpy_s(bytes, size, _in.data() + _pos, readSize) != EOK) { 1244 return readSize; 1245 } 1246 _pos += readSize; 1247 return readSize; 1248 } 1249 1250 private: 1251 const std::string &_in; 1252 size_t _pos; 1253 }; 1254 // mytype begin, just support base type, but really use protobuf raw type(uint32) 1255 template<> struct Serializer<uint8_t> { 1256 static void Serialize(uint32_t tag, uint8_t value, FlagsType<>, Writer &out, bool force = false) 1257 { 1258 Serializer<uint32_t>::Serialize(tag, value, FlagsType(), out, force); 1259 } 1260 1261 static void SerializePacked(uint8_t value, FlagsType<>, Writer &out) 1262 { 1263 Serializer<uint32_t>::SerializePacked(value, FlagsType(), out); 1264 } 1265 1266 static bool Parse(WireType wire_type, uint8_t &value, FlagsType<>, Reader &in) 1267 { 1268 uint32_t intermedaite_value; 1269 if (Serializer<uint32_t>::Parse(wire_type, intermedaite_value, FlagsType<>(), in)) { 1270 value = static_cast<uint8_t>(intermedaite_value); 1271 return true; 1272 } 1273 return false; 1274 } 1275 1276 static bool ParsePacked(uint8_t &value, FlagsType<>, Reader &in) 1277 { 1278 uint32_t intermedaite_value; 1279 if (Serializer<uint32_t>::ParsePacked(intermedaite_value, FlagsType<>(), in)) { 1280 value = static_cast<uint8_t>(intermedaite_value); 1281 return true; 1282 } 1283 return false; 1284 } 1285 }; 1286 template<> struct Serializer<uint16_t> { 1287 static void Serialize(uint32_t tag, uint16_t value, FlagsType<>, Writer &out, bool force = false) 1288 { 1289 Serializer<uint32_t>::Serialize(tag, value, FlagsType(), out, force); 1290 } 1291 1292 static void SerializePacked(uint16_t value, FlagsType<>, Writer &out) 1293 { 1294 Serializer<uint32_t>::SerializePacked(value, FlagsType(), out); 1295 } 1296 1297 static bool Parse(WireType wire_type, uint16_t &value, FlagsType<>, Reader &in) 1298 { 1299 uint32_t intermedaite_value; 1300 if (Serializer<uint32_t>::Parse(wire_type, intermedaite_value, FlagsType<>(), in)) { 1301 value = static_cast<uint16_t>(intermedaite_value); 1302 return true; 1303 } 1304 return false; 1305 } 1306 1307 static bool ParsePacked(uint16_t &value, FlagsType<>, Reader &in) 1308 { 1309 uint32_t intermedaite_value; 1310 if (Serializer<uint32_t>::ParsePacked(intermedaite_value, FlagsType<>(), in)) { 1311 value = static_cast<uint16_t>(intermedaite_value); 1312 return true; 1313 } 1314 return false; 1315 } 1316 }; 1317 // mytype finish 1318 1319 template<class T> std::string SerializeToString(const T &value) 1320 { 1321 std::string out; 1322 StringWriter stringOut(out); 1323 SerialDetail::WriteMessage(value, MessageType<T>(), stringOut); 1324 return out; 1325 } 1326 1327 template<class T> bool ParseFromString(T &value, const std::string &in) 1328 { 1329 StringReader stringIn(in); 1330 return SerialDetail::ReadMessage(value, MessageType<T>(), stringIn); 1331 } 1332 } 1333 // clang-format on 1334 } // Hdc 1335 #endif // HDC_SERIAL_STRUCT_DEFINE_H 1336