serialization.h revision e4eec20f6263f4a42ae462456f60ea6c4518bb0a
1#ifndef ANDROID_PDX_RPC_SERIALIZATION_H_ 2#define ANDROID_PDX_RPC_SERIALIZATION_H_ 3 4#include <cstdint> 5#include <cstring> 6#include <iterator> 7#include <map> 8#include <numeric> 9#include <sstream> 10#include <string> 11#include <tuple> 12#include <type_traits> 13#include <unordered_map> 14#include <utility> 15#include <vector> 16 17#include <pdx/channel_handle.h> 18#include <pdx/file_handle.h> 19#include <pdx/message_reader.h> 20#include <pdx/message_writer.h> 21#include <pdx/trace.h> 22#include <pdx/utility.h> 23 24#include "array_wrapper.h" 25#include "default_initialization_allocator.h" 26#include "encoding.h" 27#include "pointer_wrapper.h" 28#include "string_wrapper.h" 29#include "variant.h" 30 31namespace android { 32namespace pdx { 33namespace rpc { 34 35// Automatic serialization/deserialization library based on MessagePack 36// (http://msgpack.org). This library provides top level Serialize() and 37// Deserialize() functions to encode/decode a variety of data types. 38// 39// The following data types are supported: 40// * Standard signed integer types: int8_t, int16_t, int32_t, and int64_t. 41// * Regular signed integer types equivalent to the standard types: 42// signed char, short, int, long, and long long. 43// * Standard unsigned integer types: uint8_t, uint16_t, uint32_t, and 44// uint64_t. 45// * Regular unsigned integer types equivalent to the standard types: 46// unsigned char, unsigned short, unsigned int, unsigned long, 47// and unsigned long long. 48// * char without signed/unsigned qualifiers. 49// * bool. 50// * std::vector with value type of any supported type, including nesting. 51// * std::string. 52// * std::tuple with elements of any supported type, including nesting. 53// * std::pair with elements of any supported type, including nesting. 54// * std::map with keys and values of any supported type, including nesting. 55// * std::unordered_map with keys and values of any supported type, including 56// nesting. 57// * std::array with values of any supported type, including nesting. 58// * ArrayWrapper of any supported basic type. 59// * BufferWrapper of any POD type. 60// * StringWrapper of any supported char type. 61// * User types with correctly defined SerializableMembers member type. 62// 63// Planned support for: 64// * std::basic_string with all supported char types. 65 66// Counting template for managing template recursion. 67template <std::size_t N> 68struct Index {}; 69 70// Forward declaration of traits type to access types with a SerializedMembers 71// member type. 72template <typename T> 73class SerializableTraits; 74 75template <typename T, typename... MemberPointers> 76struct SerializableMembersType; 77 78// Utility to deduce the template type from a derived type. 79template <template <typename...> class TT, typename... Ts> 80std::true_type DeduceTemplateType(const TT<Ts...>*); 81template <template <typename...> class TT> 82std::false_type DeduceTemplateType(...); 83 84// Utility determining whether template type TT<...> is a base of type T. 85template <template <typename...> class TT, typename T> 86using IsTemplateBaseOf = decltype(DeduceTemplateType<TT>(std::declval<T*>())); 87 88// Utility type for SFINAE in HasHasSerializableMembers. 89template <typename... Ts> 90using TrySerializableMembersType = void; 91 92// Determines whether type T has a member type named SerializableMembers of 93// template type SerializableMembersType. 94template <typename, typename = void> 95struct HasSerializableMembers : std::false_type {}; 96template <typename T> 97struct HasSerializableMembers< 98 T, TrySerializableMembersType<typename T::SerializableMembers>> 99 : std::integral_constant< 100 bool, IsTemplateBaseOf<SerializableMembersType, 101 typename T::SerializableMembers>::value> {}; 102 103// Utility to simplify overload enable expressions for types with correctly 104// defined SerializableMembers. 105template <typename T> 106using EnableIfHasSerializableMembers = 107 typename std::enable_if<HasSerializableMembers<T>::value>::type; 108 109// Utility to simplify overload enable expressions for enum types. 110template <typename T, typename ReturnType = void> 111using EnableIfEnum = 112 typename std::enable_if<std::is_enum<T>::value, ReturnType>::type; 113 114/////////////////////////////////////////////////////////////////////////////// 115// Error Reporting // 116/////////////////////////////////////////////////////////////////////////////// 117 118// Error codes returned by the deserialization code. 119enum class ErrorCode { 120 NO_ERROR = 0, 121 UNEXPECTED_ENCODING, 122 UNEXPECTED_TYPE_SIZE, 123 INSUFFICIENT_BUFFER, 124 INSUFFICIENT_DESTINATION_SIZE, 125 GET_FILE_DESCRIPTOR_FAILED, 126 GET_CHANNEL_HANDLE_FAILED, 127 INVALID_VARIANT_ELEMENT, 128}; 129 130// Type for errors returned by the deserialization code. 131class ErrorType { 132 public: 133 ErrorType() : error_code_(ErrorCode::NO_ERROR) {} 134 135 // ErrorType constructor for generic error codes. Explicitly not explicit, 136 // implicit conversion from ErrorCode to ErrorType is desirable behavior. 137 // NOLINTNEXTLINE(runtime/explicit) 138 ErrorType(ErrorCode error_code) : error_code_(error_code) {} 139 140 // ErrorType constructor for encoding type errors. 141 ErrorType(ErrorCode error_code, EncodingClass encoding_class, 142 EncodingType encoding_type) 143 : error_code_(error_code) { 144 unexpected_encoding_.encoding_class = encoding_class; 145 unexpected_encoding_.encoding_type = encoding_type; 146 } 147 148 // Evaluates to true if the ErrorType represents an error. 149 explicit operator bool() const { return error_code_ != ErrorCode::NO_ERROR; } 150 151 operator ErrorCode() const { return error_code_; } 152 ErrorCode error_code() const { return error_code_; } 153 154 // Accessors for extra info about unexpected encoding errors. 155 EncodingClass encoding_class() const { 156 return unexpected_encoding_.encoding_class; 157 } 158 EncodingType encoding_type() const { 159 return unexpected_encoding_.encoding_type; 160 } 161 162 operator std::string() const { 163 std::ostringstream stream; 164 165 switch (error_code_) { 166 case ErrorCode::NO_ERROR: 167 return "NO_ERROR"; 168 case ErrorCode::UNEXPECTED_ENCODING: 169 stream << "UNEXPECTED_ENCODING: " << static_cast<int>(encoding_class()) 170 << ", " << static_cast<int>(encoding_type()); 171 return stream.str(); 172 case ErrorCode::UNEXPECTED_TYPE_SIZE: 173 return "UNEXPECTED_TYPE_SIZE"; 174 case ErrorCode::INSUFFICIENT_BUFFER: 175 return "INSUFFICIENT_BUFFER"; 176 case ErrorCode::INSUFFICIENT_DESTINATION_SIZE: 177 return "INSUFFICIENT_DESTINATION_SIZE"; 178 default: 179 return "[Unknown Error]"; 180 } 181 } 182 183 private: 184 ErrorCode error_code_; 185 186 // Union of extra information for different error code types. 187 union { 188 // UNEXPECTED_ENCODING. 189 struct { 190 EncodingClass encoding_class; 191 EncodingType encoding_type; 192 } unexpected_encoding_; 193 }; 194}; 195 196/////////////////////////////////////////////////////////////////////////////// 197// Object Size // 198/////////////////////////////////////////////////////////////////////////////// 199 200inline constexpr std::size_t GetSerializedSize(const bool& b) { 201 return GetEncodingSize(EncodeType(b)); 202} 203 204// Overloads of GetSerializedSize() for standard integer types. 205inline constexpr std::size_t GetSerializedSize(const char& c) { 206 return GetEncodingSize(EncodeType(c)); 207} 208inline constexpr std::size_t GetSerializedSize(const std::uint8_t& i) { 209 return GetEncodingSize(EncodeType(i)); 210} 211inline constexpr std::size_t GetSerializedSize(const std::int8_t& i) { 212 return GetEncodingSize(EncodeType(i)); 213} 214inline constexpr std::size_t GetSerializedSize(const std::uint16_t& i) { 215 return GetEncodingSize(EncodeType(i)); 216} 217inline constexpr std::size_t GetSerializedSize(const std::int16_t& i) { 218 return GetEncodingSize(EncodeType(i)); 219} 220inline constexpr std::size_t GetSerializedSize(const std::uint32_t& i) { 221 return GetEncodingSize(EncodeType(i)); 222} 223inline constexpr std::size_t GetSerializedSize(const std::int32_t& i) { 224 return GetEncodingSize(EncodeType(i)); 225} 226inline constexpr std::size_t GetSerializedSize(const std::uint64_t& i) { 227 return GetEncodingSize(EncodeType(i)); 228} 229inline constexpr std::size_t GetSerializedSize(const std::int64_t& i) { 230 return GetEncodingSize(EncodeType(i)); 231} 232 233inline constexpr std::size_t GetSerializedSize(const float& f) { 234 return GetEncodingSize(EncodeType(f)); 235} 236inline constexpr std::size_t GetSerializedSize(const double& d) { 237 return GetEncodingSize(EncodeType(d)); 238} 239 240// Overload for enum types. 241template <typename T> 242inline EnableIfEnum<T, std::size_t> GetSerializedSize(T v) { 243 return GetSerializedSize(static_cast<std::underlying_type_t<T>>(v)); 244} 245 246// Forward declaration for nested definitions. 247inline std::size_t GetSerializedSize(const EmptyVariant&); 248template <typename... Types> 249inline std::size_t GetSerializedSize(const Variant<Types...>&); 250template <typename T, typename Enabled> 251inline constexpr std::size_t GetSerializedSize(const T&); 252template <typename T> 253inline constexpr std::size_t GetSerializedSize(const PointerWrapper<T>&); 254inline constexpr std::size_t GetSerializedSize(const std::string&); 255template <typename T> 256inline constexpr std::size_t GetSerializedSize(const StringWrapper<T>&); 257template <typename T> 258inline constexpr std::size_t GetSerializedSize(const BufferWrapper<T>&); 259template <FileHandleMode Mode> 260inline constexpr std::size_t GetSerializedSize(const FileHandle<Mode>&); 261template <ChannelHandleMode Mode> 262inline constexpr std::size_t GetSerializedSize(const ChannelHandle<Mode>&); 263template <typename T, typename Allocator> 264inline std::size_t GetSerializedSize(const std::vector<T, Allocator>& v); 265template <typename Key, typename T, typename Compare, typename Allocator> 266inline std::size_t GetSerializedSize( 267 const std::map<Key, T, Compare, Allocator>& m); 268template <typename Key, typename T, typename Hash, typename KeyEqual, 269 typename Allocator> 270inline std::size_t GetSerializedSize( 271 const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>&); 272template <typename T> 273inline std::size_t GetSerializedSize(const ArrayWrapper<T>&); 274template <typename T, std::size_t Size> 275inline std::size_t GetSerializedSize(const std::array<T, Size>& v); 276template <typename T, typename U> 277inline std::size_t GetSerializedSize(const std::pair<T, U>& p); 278template <typename... T> 279inline std::size_t GetSerializedSize(const std::tuple<T...>& tuple); 280 281// Overload for empty variant type. 282inline std::size_t GetSerializedSize(const EmptyVariant& empty) { 283 return GetEncodingSize(EncodeType(empty)); 284} 285 286// Overload for Variant types. 287template <typename... Types> 288inline std::size_t GetSerializedSize(const Variant<Types...>& variant) { 289 return GetEncodingSize(EncodeType(variant)) + 290 GetSerializedSize(variant.index()) + 291 variant.Visit( 292 [](const auto& value) { return GetSerializedSize(value); }); 293} 294 295// Overload for structs/classes with SerializableMembers defined. 296template <typename T, typename Enabled = EnableIfHasSerializableMembers<T>> 297inline constexpr std::size_t GetSerializedSize(const T& value) { 298 return SerializableTraits<T>::GetSerializedSize(value); 299} 300 301// Overload for PointerWrapper. 302template <typename T> 303inline constexpr std::size_t GetSerializedSize(const PointerWrapper<T>& p) { 304 return GetSerializedSize(p.Dereference()); 305} 306 307// Overload for std::string. 308inline constexpr std::size_t GetSerializedSize(const std::string& s) { 309 return GetEncodingSize(EncodeType(s)) + 310 s.length() * sizeof(std::string::value_type); 311} 312 313// Overload for StringWrapper. 314template <typename T> 315inline constexpr std::size_t GetSerializedSize(const StringWrapper<T>& s) { 316 return GetEncodingSize(EncodeType(s)) + 317 s.length() * sizeof(typename StringWrapper<T>::value_type); 318} 319 320// Overload for BufferWrapper types. 321template <typename T> 322inline constexpr std::size_t GetSerializedSize(const BufferWrapper<T>& b) { 323 return GetEncodingSize(EncodeType(b)) + 324 b.size() * sizeof(typename BufferWrapper<T>::value_type); 325} 326 327// Overload for FileHandle. FileHandle is encoded as a FIXEXT2, with a type code 328// of "FileHandle" and a signed 16-bit offset into the pushed fd array. Empty 329// FileHandles are encoded with an array index of -1. 330template <FileHandleMode Mode> 331inline constexpr std::size_t GetSerializedSize(const FileHandle<Mode>& fd) { 332 return GetEncodingSize(EncodeType(fd)) + sizeof(std::int16_t); 333} 334 335// Overload for ChannelHandle. ChannelHandle is encoded as a FIXEXT4, with a 336// type code of "ChannelHandle" and a signed 32-bit offset into the pushed 337// channel array. Empty ChannelHandles are encoded with an array index of -1. 338template <ChannelHandleMode Mode> 339inline constexpr std::size_t GetSerializedSize( 340 const ChannelHandle<Mode>& channel_handle) { 341 return GetEncodingSize(EncodeType(channel_handle)) + sizeof(std::int32_t); 342} 343 344// Overload for standard vector types. 345template <typename T, typename Allocator> 346inline std::size_t GetSerializedSize(const std::vector<T, Allocator>& v) { 347 return std::accumulate(v.begin(), v.end(), GetEncodingSize(EncodeType(v)), 348 [](const std::size_t& sum, const T& object) { 349 return sum + GetSerializedSize(object); 350 }); 351} 352 353// Overload for standard map types. 354template <typename Key, typename T, typename Compare, typename Allocator> 355inline std::size_t GetSerializedSize( 356 const std::map<Key, T, Compare, Allocator>& v) { 357 return std::accumulate( 358 v.begin(), v.end(), GetEncodingSize(EncodeType(v)), 359 [](const std::size_t& sum, const std::pair<Key, T>& object) { 360 return sum + GetSerializedSize(object.first) + 361 GetSerializedSize(object.second); 362 }); 363} 364 365// Overload for standard unordered_map types. 366template <typename Key, typename T, typename Hash, typename KeyEqual, 367 typename Allocator> 368inline std::size_t GetSerializedSize( 369 const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& v) { 370 return std::accumulate( 371 v.begin(), v.end(), GetEncodingSize(EncodeType(v)), 372 [](const std::size_t& sum, const std::pair<Key, T>& object) { 373 return sum + GetSerializedSize(object.first) + 374 GetSerializedSize(object.second); 375 }); 376} 377 378// Overload for ArrayWrapper types. 379template <typename T> 380inline std::size_t GetSerializedSize(const ArrayWrapper<T>& v) { 381 return std::accumulate(v.begin(), v.end(), GetEncodingSize(EncodeType(v)), 382 [](const std::size_t& sum, const T& object) { 383 return sum + GetSerializedSize(object); 384 }); 385} 386 387// Overload for std::array types. 388template <typename T, std::size_t Size> 389inline std::size_t GetSerializedSize(const std::array<T, Size>& v) { 390 return std::accumulate(v.begin(), v.end(), GetEncodingSize(EncodeType(v)), 391 [](const std::size_t& sum, const T& object) { 392 return sum + GetSerializedSize(object); 393 }); 394} 395 396// Overload for std::pair. 397template <typename T, typename U> 398inline std::size_t GetSerializedSize(const std::pair<T, U>& p) { 399 return GetEncodingSize(EncodeType(p)) + GetSerializedSize(p.first) + 400 GetSerializedSize(p.second); 401} 402 403// Stops template recursion when the last tuple element is reached. 404template <typename... T> 405inline std::size_t GetTupleSize(const std::tuple<T...>&, Index<0>) { 406 return 0; 407} 408 409// Gets the size of each element in a tuple recursively. 410template <typename... T, std::size_t index> 411inline std::size_t GetTupleSize(const std::tuple<T...>& tuple, Index<index>) { 412 return GetTupleSize(tuple, Index<index - 1>()) + 413 GetSerializedSize(std::get<index - 1>(tuple)); 414} 415 416// Overload for tuple types. Gets the size of the tuple, recursing 417// through the elements. 418template <typename... T> 419inline std::size_t GetSerializedSize(const std::tuple<T...>& tuple) { 420 return GetEncodingSize(EncodeType(tuple)) + 421 GetTupleSize(tuple, Index<sizeof...(T)>()); 422} 423 424// Stops template recursion when the last member of a Serializable 425// type is reached. 426template <typename Members, typename T> 427inline std::size_t GetMemberSize(const T&, Index<0>) { 428 return 0; 429} 430 431// Gets the size of each member of a Serializable type recursively. 432template <typename Members, typename T, std::size_t index> 433inline std::size_t GetMemberSize(const T& object, Index<index>) { 434 return GetMemberSize<Members>(object, Index<index - 1>()) + 435 GetSerializedSize(Members::template At<index - 1>::Resolve(object)); 436} 437 438// Gets the size of a type using the given SerializableMembersType 439// type. 440template <typename Members, typename T> 441inline std::size_t GetMembersSize(const T& object) { 442 return GetMemberSize<Members>(object, Index<Members::MemberCount>()); 443} 444 445/////////////////////////////////////////////////////////////////////////////// 446// Object Serialization // 447/////////////////////////////////////////////////////////////////////////////// 448 449// 450// SerializeRaw() converts a primitive array or type into a raw byte string. 451// These functions are named differently from SerializeObject() expressly to 452// avoid catch-all specialization of that template, which can be difficult to 453// detect otherwise. 454// 455 456inline void WriteRawData(void*& dest, const void* src, size_t size) { 457 memcpy(dest, src, size); 458 dest = static_cast<uint8_t*>(dest) + size; 459} 460 461// Serializes a primitive array into a raw byte string. 462template <typename T, 463 typename = typename std::enable_if<std::is_pod<T>::value>::type> 464inline void SerializeRaw(const T& value, void*& buffer) { 465 WriteRawData(buffer, &value, sizeof(value)); 466} 467 468inline void SerializeEncoding(EncodingType encoding, void*& buffer) { 469 SerializeRaw(encoding, buffer); 470} 471 472inline void SerializeType(const bool& value, void*& buffer) { 473 const EncodingType encoding = EncodeType(value); 474 SerializeEncoding(encoding, buffer); 475} 476 477// Serializes the type code, extended type code, and size for 478// extension types. 479inline void SerializeExtEncoding(EncodingType encoding, 480 EncodingExtType ext_type, std::size_t size, 481 void*& buffer) { 482 SerializeEncoding(encoding, buffer); 483 if (encoding == ENCODING_TYPE_EXT8) { 484 std::uint8_t length = size; 485 SerializeRaw(length, buffer); 486 } else if (encoding == ENCODING_TYPE_EXT16) { 487 std::uint16_t length = size; 488 SerializeRaw(length, buffer); 489 } else if (encoding == ENCODING_TYPE_EXT32) { 490 std::uint32_t length = size; 491 SerializeRaw(length, buffer); 492 } else /* if (IsFixextEncoding(encoding) */ { 493 // Encoding byte contains the fixext length, nothing else to do. 494 } 495 SerializeRaw(ext_type, buffer); 496} 497 498// Serializes the type code for file descriptor types. 499template <FileHandleMode Mode> 500inline void SerializeType(const FileHandle<Mode>& value, void*& buffer) { 501 SerializeExtEncoding(EncodeType(value), ENCODING_EXT_TYPE_FILE_DESCRIPTOR, 2, 502 buffer); 503} 504 505// Serializes the type code for channel handle types. 506template <ChannelHandleMode Mode> 507inline void SerializeType(const ChannelHandle<Mode>& handle, void*& buffer) { 508 SerializeExtEncoding(EncodeType(handle), ENCODING_EXT_TYPE_CHANNEL_HANDLE, 4, 509 buffer); 510} 511 512// Serializes type code for variant types. 513template <typename... Types> 514inline void SerializeType(const Variant<Types...>& value, void*& buffer) { 515 const EncodingType encoding = EncodeType(value); 516 SerializeEncoding(encoding, buffer); 517} 518 519// Serializes the type code for string types. 520template <typename StringType> 521inline void SerializeStringType(const StringType& value, void*& buffer) { 522 const EncodingType encoding = EncodeType(value); 523 SerializeEncoding(encoding, buffer); 524 if (encoding == ENCODING_TYPE_STR8) { 525 std::uint8_t length = value.length(); 526 SerializeRaw(length, buffer); 527 } else if (encoding == ENCODING_TYPE_STR16) { 528 std::uint16_t length = value.length(); 529 SerializeRaw(length, buffer); 530 } else if (encoding == ENCODING_TYPE_STR32) { 531 std::uint32_t length = value.length(); 532 SerializeRaw(length, buffer); 533 } else /* if (IsFixstrEncoding(encoding) */ { 534 // Encoding byte contains the fixstr length, nothing else to do. 535 } 536} 537 538// Serializes the type code for std::string and StringWrapper. These types are 539// interchangeable and must serialize to the same format. 540inline void SerializeType(const std::string& value, void*& buffer) { 541 SerializeStringType(value, buffer); 542} 543template <typename T> 544inline void SerializeType(const StringWrapper<T>& value, void*& buffer) { 545 SerializeStringType(value, buffer); 546} 547 548// Serializes the type code for bin types. 549inline void SerializeBinEncoding(EncodingType encoding, std::size_t size, 550 void*& buffer) { 551 SerializeEncoding(encoding, buffer); 552 if (encoding == ENCODING_TYPE_BIN8) { 553 std::uint8_t length = size; 554 SerializeRaw(length, buffer); 555 } else if (encoding == ENCODING_TYPE_BIN16) { 556 std::uint16_t length = size; 557 SerializeRaw(length, buffer); 558 } else if (encoding == ENCODING_TYPE_BIN32) { 559 std::uint32_t length = size; 560 SerializeRaw(length, buffer); 561 } else { 562 // Invalid encoding for BIN type. 563 } 564} 565 566// Serializes the type code for BufferWrapper types. 567template <typename T> 568inline void SerializeType(const BufferWrapper<T>& value, void*& buffer) { 569 const EncodingType encoding = EncodeType(value); 570 SerializeBinEncoding( 571 encoding, value.size() * sizeof(typename BufferWrapper<T>::value_type), 572 buffer); 573} 574 575// Serializes the array encoding type and length. 576inline void SerializeArrayEncoding(EncodingType encoding, std::size_t size, 577 void*& buffer) { 578 SerializeEncoding(encoding, buffer); 579 if (encoding == ENCODING_TYPE_ARRAY16) { 580 std::uint16_t length = size; 581 SerializeRaw(length, buffer); 582 } else if (encoding == ENCODING_TYPE_ARRAY32) { 583 std::uint32_t length = size; 584 SerializeRaw(length, buffer); 585 } else /* if (IsFixarrayEncoding(encoding) */ { 586 // Encoding byte contains the fixarray length, nothing else to do. 587 } 588} 589 590// Serializes the map encoding type and length. 591inline void SerializeMapEncoding(EncodingType encoding, std::size_t size, 592 void*& buffer) { 593 SerializeEncoding(encoding, buffer); 594 if (encoding == ENCODING_TYPE_MAP16) { 595 std::uint16_t length = size; 596 SerializeRaw(length, buffer); 597 } else if (encoding == ENCODING_TYPE_MAP32) { 598 std::uint32_t length = size; 599 SerializeRaw(length, buffer); 600 } else /* if (IsFixmapEncoding(encoding) */ { 601 // Encoding byte contains the fixmap length, nothing else to do. 602 } 603} 604 605// Serializes the type code for array types. 606template <typename ArrayType> 607inline void SerializeArrayType(const ArrayType& value, std::size_t size, 608 void*& buffer) { 609 const EncodingType encoding = EncodeType(value); 610 SerializeArrayEncoding(encoding, size, buffer); 611} 612 613// Serializes the type code for map types. 614template <typename MapType> 615inline void SerializeMapType(const MapType& value, std::size_t size, 616 void*& buffer) { 617 const EncodingType encoding = EncodeType(value); 618 SerializeMapEncoding(encoding, size, buffer); 619} 620 621// Serializes the type code for std::vector and ArrayWrapper. These types are 622// interchangeable and must serialize to the same format. 623template <typename T, typename Allocator> 624inline void SerializeType(const std::vector<T, Allocator>& value, 625 void*& buffer) { 626 SerializeArrayType(value, value.size(), buffer); 627} 628template <typename T> 629inline void SerializeType(const ArrayWrapper<T>& value, void*& buffer) { 630 SerializeArrayType(value, value.size(), buffer); 631} 632 633// Serializes the type code for std::array. This type serializes to the same 634// format as std::vector and ArrayWrapper and is interchangeable in certain 635// situations. 636template <typename T, std::size_t Size> 637inline void SerializeType(const std::array<T, Size>& value, void*& buffer) { 638 SerializeArrayType(value, Size, buffer); 639} 640 641// Serializes the type code for std::map types. 642template <typename Key, typename T, typename Compare, typename Allocator> 643inline void SerializeType(const std::map<Key, T, Compare, Allocator>& value, 644 void*& buffer) { 645 SerializeMapType(value, value.size(), buffer); 646} 647 648// Serializes the type code for std::unordered_map types. 649template <typename Key, typename T, typename Hash, typename KeyEqual, 650 typename Allocator> 651inline void SerializeType( 652 const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& value, 653 void*& buffer) { 654 SerializeMapType(value, value.size(), buffer); 655} 656 657// Serializes the type code for std::pair types. 658template <typename T, typename U> 659inline void SerializeType(const std::pair<T, U>& value, void*& buffer) { 660 SerializeArrayType(value, 2, buffer); 661} 662 663// Serializes the type code for std::tuple types. 664template <typename... T> 665inline void SerializeType(const std::tuple<T...>& value, void*& buffer) { 666 SerializeArrayType(value, sizeof...(T), buffer); 667} 668 669// Specialization of SerializeObject for boolean type. 670inline void SerializeObject(const bool& value, MessageWriter* /*writer*/, 671 void*& buffer) { 672 SerializeType(value, buffer); 673 // Encoding contains the boolean value, nothing else to do. 674} 675 676// Overloads of SerializeObject for float and double types. 677inline void SerializeObject(const float& value, MessageWriter* /*writer*/, 678 void*& buffer) { 679 const EncodingType encoding = EncodeType(value); 680 SerializeEncoding(encoding, buffer); 681 SerializeRaw(value, buffer); 682} 683 684inline void SerializeObject(const double& value, MessageWriter* /*writer*/, 685 void*& buffer) { 686 const EncodingType encoding = EncodeType(value); 687 SerializeEncoding(encoding, buffer); 688 SerializeRaw(value, buffer); 689} 690 691// Overloads of SerializeObject() for standard integer types. 692inline void SerializeObject(const char& value, MessageWriter* /*writer*/, 693 void*& buffer) { 694 const EncodingType encoding = EncodeType(value); 695 SerializeEncoding(encoding, buffer); 696 if (encoding == ENCODING_TYPE_UINT8) { 697 SerializeRaw(value, buffer); 698 } else /* if (IsUnsignedFixintEncoding(encoding) */ { 699 // Encoding byte contains the value, nothing else to do. 700 } 701} 702 703inline void SerializeObject(const int8_t& value, MessageWriter* /*writer*/, 704 void*& buffer) { 705 const EncodingType encoding = EncodeType(value); 706 SerializeEncoding(encoding, buffer); 707 if (encoding == ENCODING_TYPE_INT8) { 708 SerializeRaw(value, buffer); 709 } else /* if (IsFixintEncoding(encoding) */ { 710 // Encoding byte contains the value, nothing else to do. 711 } 712} 713 714inline void SerializeObject(const uint8_t& value, MessageWriter* /*writer*/, 715 void*& buffer) { 716 const EncodingType encoding = EncodeType(value); 717 SerializeEncoding(encoding, buffer); 718 if (encoding == ENCODING_TYPE_UINT8) { 719 SerializeRaw(value, buffer); 720 } else /* if (IsUnsignedFixintEncoding(encoding) */ { 721 // Encoding byte contains the value, nothing else to do. 722 } 723} 724 725inline void SerializeObject(const int16_t& value, MessageWriter* /*writer*/, 726 void*& buffer) { 727 const EncodingType encoding = EncodeType(value); 728 SerializeEncoding(encoding, buffer); 729 if (encoding == ENCODING_TYPE_INT8) { 730 const int8_t byte = value; 731 SerializeRaw(byte, buffer); 732 } else if (encoding == ENCODING_TYPE_INT16) { 733 SerializeRaw(value, buffer); 734 } else /* if (IsFixintEncoding(encoding) */ { 735 // Encoding byte contains the value, nothing else to do. 736 } 737} 738 739inline void SerializeObject(const uint16_t& value, MessageWriter* /*writer*/, 740 void*& buffer) { 741 const EncodingType encoding = EncodeType(value); 742 SerializeEncoding(encoding, buffer); 743 if (encoding == ENCODING_TYPE_UINT8) { 744 const uint8_t byte = value; 745 SerializeRaw(byte, buffer); 746 } else if (encoding == ENCODING_TYPE_UINT16) { 747 SerializeRaw(value, buffer); 748 } else /* if (IsUnsignedFixintEncoding(encoding) */ { 749 // Encoding byte contains the value, nothing else to do. 750 } 751} 752 753inline void SerializeObject(const int32_t& value, MessageWriter* /*writer*/, 754 void*& buffer) { 755 const EncodingType encoding = EncodeType(value); 756 SerializeEncoding(encoding, buffer); 757 if (encoding == ENCODING_TYPE_INT8) { 758 const int8_t byte = value; 759 SerializeRaw(byte, buffer); 760 } else if (encoding == ENCODING_TYPE_INT16) { 761 const int16_t half = value; 762 SerializeRaw(half, buffer); 763 } else if (encoding == ENCODING_TYPE_INT32) { 764 SerializeRaw(value, buffer); 765 } else /* if (IsFixintEncoding(encoding) */ { 766 // Encoding byte contains the value, nothing else to do. 767 } 768} 769 770inline void SerializeObject(const uint32_t& value, MessageWriter* /*writer*/, 771 void*& buffer) { 772 const EncodingType encoding = EncodeType(value); 773 SerializeEncoding(encoding, buffer); 774 if (encoding == ENCODING_TYPE_UINT8) { 775 const uint8_t byte = value; 776 SerializeRaw(byte, buffer); 777 } else if (encoding == ENCODING_TYPE_UINT16) { 778 const uint16_t half = value; 779 SerializeRaw(half, buffer); 780 } else if (encoding == ENCODING_TYPE_UINT32) { 781 SerializeRaw(value, buffer); 782 } else /* if (IsUnsignedFixintEncoding(encoding) */ { 783 // Encoding byte contains the value, nothing else to do. 784 } 785} 786 787inline void SerializeObject(const int64_t& value, MessageWriter* /*writer*/, 788 void*& buffer) { 789 const EncodingType encoding = EncodeType(value); 790 SerializeEncoding(encoding, buffer); 791 if (encoding == ENCODING_TYPE_INT8) { 792 const int8_t byte = value; 793 SerializeRaw(byte, buffer); 794 } else if (encoding == ENCODING_TYPE_INT16) { 795 const int16_t half = value; 796 SerializeRaw(half, buffer); 797 } else if (encoding == ENCODING_TYPE_INT32) { 798 const int32_t word = value; 799 SerializeRaw(word, buffer); 800 } else if (encoding == ENCODING_TYPE_INT64) { 801 SerializeRaw(value, buffer); 802 } else /* if (IsFixintEncoding(encoding) */ { 803 // Encoding byte contains the value, nothing else to do. 804 } 805} 806 807inline void SerializeObject(const uint64_t& value, MessageWriter* /*writer*/, 808 void*& buffer) { 809 const EncodingType encoding = EncodeType(value); 810 SerializeEncoding(encoding, buffer); 811 if (encoding == ENCODING_TYPE_UINT8) { 812 const uint8_t byte = value; 813 SerializeRaw(byte, buffer); 814 } else if (encoding == ENCODING_TYPE_UINT16) { 815 const uint16_t half = value; 816 SerializeRaw(half, buffer); 817 } else if (encoding == ENCODING_TYPE_UINT32) { 818 const uint32_t word = value; 819 SerializeRaw(word, buffer); 820 } else if (encoding == ENCODING_TYPE_UINT64) { 821 SerializeRaw(value, buffer); 822 } else /* if (IsUnsignedFixintEncoding(encoding) */ { 823 // Encoding byte contains the value, nothing else to do. 824 } 825} 826 827// Serialize enum types. 828template <typename T> 829inline EnableIfEnum<T> SerializeObject(const T& value, MessageWriter* writer, 830 void*& buffer) { 831 SerializeObject(static_cast<std::underlying_type_t<T>>(value), writer, 832 buffer); 833} 834 835// Forward declaration for nested definitions. 836inline void SerializeObject(const EmptyVariant&, MessageWriter*, void*&); 837template <typename... Types> 838inline void SerializeObject(const Variant<Types...>&, MessageWriter*, void*&); 839template <typename T, typename Enabled> 840inline void SerializeObject(const T&, MessageWriter*, void*&); 841template <typename T> 842inline void SerializeObject(const PointerWrapper<T>&, MessageWriter*, void*&); 843template <FileHandleMode Mode> 844inline void SerializeObject(const FileHandle<Mode>&, MessageWriter*, void*&); 845template <ChannelHandleMode Mode> 846inline void SerializeObject(const ChannelHandle<Mode>&, MessageWriter*, void*&); 847template <typename T, typename Allocator> 848inline void SerializeObject(const BufferWrapper<std::vector<T, Allocator>>&, MessageWriter*, void*&); 849template <typename T> 850inline void SerializeObject(const BufferWrapper<T*>&, MessageWriter*, void*&); 851inline void SerializeObject(const std::string&, MessageWriter*, void*&); 852template <typename T> 853inline void SerializeObject(const StringWrapper<T>&, MessageWriter*, void*&); 854template <typename T, typename Allocator> 855inline void SerializeObject(const std::vector<T, Allocator>&, MessageWriter*, void*&); 856template <typename T> 857inline void SerializeObject(const ArrayWrapper<T>&, MessageWriter*, void*&); 858template <typename T, std::size_t Size> 859inline void SerializeObject(const std::array<T, Size>&, MessageWriter*, void*&); 860template <typename Key, typename T, typename Compare, typename Allocator> 861inline void SerializeObject(const std::map<Key, T, Compare, Allocator>&, MessageWriter*, void*&); 862template <typename Key, typename T, typename Hash, typename KeyEqual, 863 typename Allocator> 864inline void SerializeObject( 865 const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>&, MessageWriter*, void*&); 866template <typename T, typename U> 867inline void SerializeObject(const std::pair<T, U>&, MessageWriter*, void*&); 868template <typename... T> 869inline void SerializeObject(const std::tuple<T...>&, MessageWriter*, void*&); 870 871// Overload for empty variant type. 872inline void SerializeObject(const EmptyVariant& empty, 873 MessageWriter* /*writer*/, void*& buffer) { 874 const EncodingType encoding = EncodeType(empty); 875 SerializeEncoding(encoding, buffer); 876} 877 878// Overload for Variant types. 879template <typename... Types> 880inline void SerializeObject(const Variant<Types...>& variant, 881 MessageWriter* writer, void*& buffer) { 882 SerializeType(variant, buffer); 883 SerializeObject(variant.index(), writer, buffer); 884 return variant.Visit([writer, &buffer](const auto& value) { 885 return SerializeObject(value, writer, buffer); 886 }); 887} 888 889// Overload for serializable structure/class types. 890template <typename T, typename Enabled = EnableIfHasSerializableMembers<T>> 891inline void SerializeObject(const T& value, MessageWriter* writer, 892 void*& buffer) { 893 SerializableTraits<T>::SerializeObject(value, writer, buffer); 894} 895 896// Serializes the payload of a PointerWrapper. 897template <typename T> 898inline void SerializeObject(const PointerWrapper<T>& pointer, 899 MessageWriter* writer, void*& buffer) { 900 SerializeObject(pointer.Dereference(), writer, buffer); 901} 902 903// Serializes the payload of file descriptor types. 904template <FileHandleMode Mode> 905inline void SerializeObject(const FileHandle<Mode>& fd, MessageWriter* writer, 906 void*& buffer) { 907 SerializeType(fd, buffer); 908 const FileReference value = 909 writer->GetOutputResourceMapper()->PushFileHandle(fd); 910 SerializeRaw(value, buffer); 911} 912 913// Serializes the payload of channel handle types. 914template <ChannelHandleMode Mode> 915inline void SerializeObject(const ChannelHandle<Mode>& handle, 916 MessageWriter* writer, void*& buffer) { 917 SerializeType(handle, buffer); 918 const ChannelReference value = 919 writer->GetOutputResourceMapper()->PushChannelHandle(handle); 920 SerializeRaw(value, buffer); 921} 922 923// Serializes the payload of BufferWrapper types. 924template <typename T, typename Allocator> 925inline void SerializeObject(const BufferWrapper<std::vector<T, Allocator>>& b, 926 MessageWriter* /*writer*/, void*& buffer) { 927 const auto value_type_size = 928 sizeof(typename BufferWrapper<std::vector<T, Allocator>>::value_type); 929 SerializeType(b, buffer); 930 WriteRawData(buffer, b.data(), b.size() * value_type_size); 931} 932template <typename T> 933inline void SerializeObject(const BufferWrapper<T*>& b, 934 MessageWriter* /*writer*/, void*& buffer) { 935 const auto value_type_size = sizeof(typename BufferWrapper<T*>::value_type); 936 SerializeType(b, buffer); 937 WriteRawData(buffer, b.data(), b.size() * value_type_size); 938} 939 940// Serializes the payload of string types. 941template <typename StringType> 942inline void SerializeString(const StringType& s, void*& buffer) { 943 const auto value_type_size = sizeof(typename StringType::value_type); 944 SerializeType(s, buffer); 945 WriteRawData(buffer, s.data(), s.length() * value_type_size); 946} 947 948// Overload of SerializeObject() for std::string and StringWrapper. These types 949// are interchangeable and must serialize to the same format. 950inline void SerializeObject(const std::string& s, MessageWriter* /*writer*/, 951 void*& buffer) { 952 SerializeString(s, buffer); 953} 954template <typename T> 955inline void SerializeObject(const StringWrapper<T>& s, 956 MessageWriter* /*writer*/, void*& buffer) { 957 SerializeString(s, buffer); 958} 959 960// Serializes the payload of array types. 961template <typename ArrayType> 962inline void SerializeArray(const ArrayType& v, MessageWriter* writer, 963 void*& buffer) { 964 SerializeType(v, buffer); 965 for (const auto& element : v) 966 SerializeObject(element, writer, buffer); 967} 968 969// Serializes the payload for map types. 970template <typename MapType> 971inline void SerializeMap(const MapType& v, MessageWriter* writer, 972 void*& buffer) { 973 SerializeType(v, buffer); 974 for (const auto& element : v) { 975 SerializeObject(element.first, writer, buffer); 976 SerializeObject(element.second, writer, buffer); 977 } 978} 979 980// Overload of SerializeObject() for std::vector and ArrayWrapper types. These 981// types are interchangeable and must serialize to the same format. 982template <typename T, typename Allocator> 983inline void SerializeObject(const std::vector<T, Allocator>& v, 984 MessageWriter* writer, void*& buffer) { 985 SerializeArray(v, writer, buffer); 986} 987template <typename T> 988inline void SerializeObject(const ArrayWrapper<T>& v, MessageWriter* writer, 989 void*& buffer) { 990 SerializeArray(v, writer, buffer); 991} 992 993// Overload of SerializeObject() for std::array types. These types serialize to 994// the same format at std::vector and ArrayWrapper and are interchangeable in 995// certain situations. 996template <typename T, std::size_t Size> 997inline void SerializeObject(const std::array<T, Size>& v, MessageWriter* writer, 998 void*& buffer) { 999 SerializeArray(v, writer, buffer); 1000} 1001 1002// Overload of SerializeObject() for std::map types. 1003template <typename Key, typename T, typename Compare, typename Allocator> 1004inline void SerializeObject(const std::map<Key, T, Compare, Allocator>& v, 1005 MessageWriter* writer, void*& buffer) { 1006 SerializeMap(v, writer, buffer); 1007} 1008 1009// Overload of SerializeObject() for std::unordered_map types. 1010template <typename Key, typename T, typename Hash, typename KeyEqual, 1011 typename Allocator> 1012inline void SerializeObject( 1013 const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& v, 1014 MessageWriter* writer, void*& buffer) { 1015 SerializeMap(v, writer, buffer); 1016} 1017 1018// Overload of SerializeObject() for std:pair types. 1019template <typename T, typename U> 1020inline void SerializeObject(const std::pair<T, U>& pair, MessageWriter* writer, 1021 void*& buffer) { 1022 SerializeType(pair, buffer); 1023 SerializeObject(pair.first, writer, buffer); 1024 SerializeObject(pair.second, writer, buffer); 1025} 1026 1027// Stops template recursion when the last tuple element is reached. 1028template <typename... T> 1029inline void SerializeTuple(const std::tuple<T...>&, MessageWriter*, void*&, 1030 Index<0>) {} 1031 1032// Serializes each element of a tuple recursively. 1033template <typename... T, std::size_t index> 1034inline void SerializeTuple(const std::tuple<T...>& tuple, MessageWriter* writer, 1035 void*& buffer, Index<index>) { 1036 SerializeTuple(tuple, writer, buffer, Index<index - 1>()); 1037 SerializeObject(std::get<index - 1>(tuple), writer, buffer); 1038} 1039 1040// Overload of SerializeObject() for tuple types. 1041template <typename... T> 1042inline void SerializeObject(const std::tuple<T...>& tuple, 1043 MessageWriter* writer, void*& buffer) { 1044 SerializeType(tuple, buffer); 1045 SerializeTuple(tuple, writer, buffer, Index<sizeof...(T)>()); 1046} 1047 1048// Stops template recursion when the last member pointer is reached. 1049template <typename Members, typename T> 1050inline void SerializeMember(const T&, MessageWriter*, void*&, Index<0>) {} 1051 1052// Serializes each member pointer recursively. 1053template <typename Members, typename T, std::size_t index> 1054inline void SerializeMember(const T& object, MessageWriter* writer, 1055 void*& buffer, Index<index>) { 1056 SerializeMember<Members>(object, writer, buffer, Index<index - 1>()); 1057 SerializeObject(Members::template At<index - 1>::Resolve(object), writer, 1058 buffer); 1059} 1060 1061// Serializes the members of a type using the given SerializableMembersType 1062// type. 1063template <typename Members, typename T> 1064inline void SerializeMembers(const T& object, MessageWriter* writer, 1065 void*& buffer) { 1066 SerializeMember<Members>(object, writer, buffer, 1067 Index<Members::MemberCount>()); 1068} 1069 1070// Top level serialization function that replaces the buffer's contents. 1071template <typename T> 1072inline void Serialize(const T& object, MessageWriter* writer) { 1073 PDX_TRACE_NAME("Serialize"); 1074 const std::size_t size = GetSerializedSize(object); 1075 1076 // Reserve the space needed for the object(s). 1077 void* buffer = writer->GetNextWriteBufferSection(size); 1078 SerializeObject(object, writer, buffer); 1079} 1080 1081/////////////////////////////////////////////////////////////////////////////// 1082// Object Deserialization // 1083/////////////////////////////////////////////////////////////////////////////// 1084 1085inline ErrorType ReadRawDataFromNextSection(void* dest, MessageReader* reader, 1086 const void*& start, 1087 const void*& end, size_t size) { 1088 while (AdvancePointer(start, size) > end) { 1089 auto remaining_size = PointerDistance(end, start); 1090 if (remaining_size > 0) { 1091 memcpy(dest, start, remaining_size); 1092 dest = AdvancePointer(dest, remaining_size); 1093 size -= remaining_size; 1094 } 1095 reader->ConsumeReadBufferSectionData(AdvancePointer(start, remaining_size)); 1096 std::tie(start, end) = reader->GetNextReadBufferSection(); 1097 if (start == end) 1098 return ErrorCode::INSUFFICIENT_BUFFER; 1099 } 1100 memcpy(dest, start, size); 1101 start = AdvancePointer(start, size); 1102 return ErrorCode::NO_ERROR; 1103} 1104 1105inline ErrorType ReadRawData(void* dest, MessageReader* /*reader*/, 1106 const void*& start, const void*& end, 1107 size_t size) { 1108 if (PDX_UNLIKELY(AdvancePointer(start, size) > end)) { 1109 // TODO(avakulenko): Enabling reading from next sections of input buffer 1110 // (using ReadRawDataFromNextSection) screws up clang compiler optimizations 1111 // (probably inefficient inlining) making the whole deserialization 1112 // code path about twice as slow. Investigate and enable more generic 1113 // deserialization code, but right now we don't really need/support this 1114 // scenario, so I keep this commented out for the time being... 1115 1116 // return ReadRawDataFromNextSection(dest, reader, start, end, size); 1117 return ErrorCode::INSUFFICIENT_BUFFER; 1118 } 1119 memcpy(dest, start, size); 1120 start = AdvancePointer(start, size); 1121 return ErrorCode::NO_ERROR; 1122} 1123 1124// Deserializes a primitive object from raw bytes. 1125template <typename T, 1126 typename = typename std::enable_if<std::is_pod<T>::value>::type> 1127inline ErrorType DeserializeRaw(T* value, MessageReader* reader, 1128 const void*& start, const void*& end) { 1129 return ReadRawData(value, reader, start, end, sizeof(T)); 1130} 1131 1132// Utility to deserialize POD types when the serialized type is different 1133// (smaller) than the target real type. This happens when values are serialized 1134// into more compact encodings. 1135template <typename SerializedType, typename RealType> 1136ErrorType DeserializeValue(RealType* real_value, MessageReader* reader, 1137 const void*& start, const void*& end) { 1138 SerializedType serialized_value; 1139 if (const auto error = 1140 DeserializeRaw(&serialized_value, reader, start, end)) { 1141 return error; 1142 } else { 1143 *real_value = serialized_value; 1144 return ErrorCode::NO_ERROR; 1145 } 1146} 1147 1148inline ErrorType DeserializeEncoding(EncodingType* encoding, 1149 MessageReader* reader, const void*& start, 1150 const void*& end) { 1151 return DeserializeRaw(encoding, reader, start, end); 1152} 1153 1154// Overload to deserialize bool type. 1155inline ErrorType DeserializeObject(bool* value, MessageReader* reader, 1156 const void*& start, const void*& end) { 1157 EncodingType encoding; 1158 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1159 return error; 1160 } else if (IsBoolEncoding(encoding)) { 1161 *value = (encoding == ENCODING_TYPE_TRUE); 1162 return ErrorCode::NO_ERROR; 1163 } else { 1164 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_BOOL, 1165 encoding); 1166 } 1167} 1168 1169// Specializations to deserialize float and double types. 1170inline ErrorType DeserializeObject(float* value, MessageReader* reader, 1171 const void*& start, const void*& end) { 1172 EncodingType encoding; 1173 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1174 return error; 1175 } else if (IsFloat32Encoding(encoding)) { 1176 return DeserializeValue<float>(value, reader, start, end); 1177 } else { 1178 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_FLOAT, 1179 encoding); 1180 } 1181} 1182 1183inline ErrorType DeserializeObject(double* value, MessageReader* reader, 1184 const void*& start, const void*& end) { 1185 EncodingType encoding; 1186 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1187 return error; 1188 } else if (IsFloat32Encoding(encoding)) { 1189 return DeserializeValue<float>(value, reader, start, end); 1190 } else if (IsFloat64Encoding(encoding)) { 1191 return DeserializeValue<double>(value, reader, start, end); 1192 } else { 1193 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_FLOAT, 1194 encoding); 1195 } 1196} 1197 1198// Specializations to deserialize standard integer types. 1199inline ErrorType DeserializeObject(char* value, MessageReader* reader, 1200 const void*& start, const void*& end) { 1201 EncodingType encoding; 1202 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1203 return error; 1204 } else if (IsUnsignedFixintEncoding(encoding)) { 1205 *value = static_cast<char>(encoding); 1206 return ErrorCode::NO_ERROR; 1207 } else if (IsUInt8Encoding(encoding)) { 1208 return DeserializeValue<char>(value, reader, start, end); 1209 } else { 1210 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_UINT, 1211 encoding); 1212 } 1213} 1214 1215inline ErrorType DeserializeObject(std::int8_t* value, MessageReader* reader, 1216 const void*& start, const void*& end) { 1217 EncodingType encoding; 1218 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1219 return error; 1220 } else if (IsFixintEncoding(encoding)) { 1221 *value = static_cast<std::int8_t>(encoding); 1222 return ErrorCode::NO_ERROR; 1223 } else if (IsInt8Encoding(encoding)) { 1224 return DeserializeValue<std::int8_t>(value, reader, start, end); 1225 } else { 1226 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_INT, 1227 encoding); 1228 } 1229} 1230 1231inline ErrorType DeserializeObject(std::uint8_t* value, MessageReader* reader, 1232 const void*& start, const void*& end) { 1233 EncodingType encoding; 1234 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1235 return error; 1236 } else if (IsUnsignedFixintEncoding(encoding)) { 1237 *value = encoding; 1238 return ErrorCode::NO_ERROR; 1239 } else if (IsUInt8Encoding(encoding)) { 1240 return DeserializeValue<std::uint8_t>(value, reader, start, end); 1241 } else { 1242 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_UINT, 1243 encoding); 1244 } 1245} 1246 1247inline ErrorType DeserializeObject(std::int16_t* value, MessageReader* reader, 1248 const void*& start, const void*& end) { 1249 EncodingType encoding; 1250 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1251 return error; 1252 } else if (IsFixintEncoding(encoding)) { 1253 *value = static_cast<std::int8_t>(encoding); 1254 return ErrorCode::NO_ERROR; 1255 } else if (IsInt8Encoding(encoding)) { 1256 return DeserializeValue<std::int8_t>(value, reader, start, end); 1257 } else if (IsInt16Encoding(encoding)) { 1258 return DeserializeValue<std::int16_t>(value, reader, start, end); 1259 } else { 1260 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_INT, 1261 encoding); 1262 } 1263} 1264 1265inline ErrorType DeserializeObject(std::uint16_t* value, MessageReader* reader, 1266 const void*& start, const void*& end) { 1267 EncodingType encoding; 1268 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1269 return error; 1270 } else if (IsUnsignedFixintEncoding(encoding)) { 1271 *value = encoding; 1272 return ErrorCode::NO_ERROR; 1273 } else if (IsUInt8Encoding(encoding)) { 1274 return DeserializeValue<std::uint8_t>(value, reader, start, end); 1275 } else if (IsUInt16Encoding(encoding)) { 1276 return DeserializeValue<std::uint16_t>(value, reader, start, end); 1277 } else { 1278 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_UINT, 1279 encoding); 1280 } 1281} 1282 1283inline ErrorType DeserializeObject(std::int32_t* value, MessageReader* reader, 1284 const void*& start, const void*& end) { 1285 EncodingType encoding; 1286 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1287 return error; 1288 } else if (IsFixintEncoding(encoding)) { 1289 *value = static_cast<std::int8_t>(encoding); 1290 return ErrorCode::NO_ERROR; 1291 } else if (IsInt8Encoding(encoding)) { 1292 return DeserializeValue<std::int8_t>(value, reader, start, end); 1293 } else if (IsInt16Encoding(encoding)) { 1294 return DeserializeValue<std::int16_t>(value, reader, start, end); 1295 } else if (IsInt32Encoding(encoding)) { 1296 return DeserializeValue<std::int32_t>(value, reader, start, end); 1297 } else { 1298 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_INT, 1299 encoding); 1300 } 1301} 1302 1303inline ErrorType DeserializeObject(std::uint32_t* value, MessageReader* reader, 1304 const void*& start, const void*& end) { 1305 EncodingType encoding; 1306 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1307 return error; 1308 } else if (IsUnsignedFixintEncoding(encoding)) { 1309 *value = encoding; 1310 return ErrorCode::NO_ERROR; 1311 } else if (IsUInt8Encoding(encoding)) { 1312 return DeserializeValue<std::uint8_t>(value, reader, start, end); 1313 } else if (IsUInt16Encoding(encoding)) { 1314 return DeserializeValue<std::uint16_t>(value, reader, start, end); 1315 } else if (IsUInt32Encoding(encoding)) { 1316 return DeserializeValue<std::uint32_t>(value, reader, start, end); 1317 } else { 1318 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_UINT, 1319 encoding); 1320 } 1321} 1322 1323inline ErrorType DeserializeObject(std::int64_t* value, MessageReader* reader, 1324 const void*& start, const void*& end) { 1325 EncodingType encoding; 1326 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1327 return error; 1328 } else if (IsFixintEncoding(encoding)) { 1329 *value = static_cast<std::int8_t>(encoding); 1330 return ErrorCode::NO_ERROR; 1331 } else if (IsInt8Encoding(encoding)) { 1332 return DeserializeValue<std::int8_t>(value, reader, start, end); 1333 } else if (IsInt16Encoding(encoding)) { 1334 return DeserializeValue<std::int16_t>(value, reader, start, end); 1335 } else if (IsInt32Encoding(encoding)) { 1336 return DeserializeValue<std::int32_t>(value, reader, start, end); 1337 } else if (IsInt64Encoding(encoding)) { 1338 return DeserializeValue<std::int64_t>(value, reader, start, end); 1339 } else { 1340 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_INT, 1341 encoding); 1342 } 1343} 1344 1345inline ErrorType DeserializeObject(std::uint64_t* value, MessageReader* reader, 1346 const void*& start, const void*& end) { 1347 EncodingType encoding; 1348 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1349 return error; 1350 } else if (IsUnsignedFixintEncoding(encoding)) { 1351 *value = encoding; 1352 return ErrorCode::NO_ERROR; 1353 } else if (IsUInt8Encoding(encoding)) { 1354 return DeserializeValue<std::uint8_t>(value, reader, start, end); 1355 } else if (IsUInt16Encoding(encoding)) { 1356 return DeserializeValue<std::uint16_t>(value, reader, start, end); 1357 } else if (IsUInt32Encoding(encoding)) { 1358 return DeserializeValue<std::uint32_t>(value, reader, start, end); 1359 } else if (IsUInt64Encoding(encoding)) { 1360 return DeserializeValue<std::uint64_t>(value, reader, start, end); 1361 } else { 1362 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_UINT, 1363 encoding); 1364 } 1365} 1366 1367template <typename T> 1368inline EnableIfEnum<T, ErrorType> DeserializeObject(T* value, 1369 MessageReader* reader, 1370 const void*& start, 1371 const void*& end) { 1372 std::underlying_type_t<T> enum_value; 1373 ErrorType error = DeserializeObject(&enum_value, reader, start, end); 1374 if (!error) 1375 *value = static_cast<T>(enum_value); 1376 return error; 1377} 1378 1379// Forward declarations for nested definitions. 1380template <typename T, typename Enabled> 1381inline ErrorType DeserializeObject(T*, MessageReader*, const void*&, 1382 const void*&); 1383template <typename T> 1384inline ErrorType DeserializeObject(PointerWrapper<T>*, MessageReader*, 1385 const void*&, const void*&); 1386inline ErrorType DeserializeObject(LocalHandle*, MessageReader*, const void*&, 1387 const void*&); 1388inline ErrorType DeserializeObject(LocalChannelHandle*, MessageReader*, 1389 const void*&, const void*&); 1390template <typename T, typename Allocator> 1391inline ErrorType DeserializeObject(BufferWrapper<std::vector<T, Allocator>>*, 1392 MessageReader*, const void*&, const void*&); 1393template <typename T> 1394inline ErrorType DeserializeObject(BufferWrapper<T*>*, MessageReader*, 1395 const void*&, const void*&); 1396inline ErrorType DeserializeObject(std::string*, MessageReader*, const void*&, 1397 const void*&); 1398template <typename T> 1399inline ErrorType DeserializeObject(StringWrapper<T>*, MessageReader*, 1400 const void*&, const void*&); 1401template <typename T, typename U> 1402inline ErrorType DeserializeObject(std::pair<T, U>*, MessageReader*, 1403 const void*&, const void*&); 1404template <typename... T> 1405inline ErrorType DeserializeObject(std::tuple<T...>*, MessageReader*, 1406 const void*&, const void*&); 1407template <typename T, typename Allocator> 1408inline ErrorType DeserializeObject(std::vector<T, Allocator>*, MessageReader*, 1409 const void*&, const void*&); 1410template <typename Key, typename T, typename Compare, typename Allocator> 1411inline ErrorType DeserializeObject(std::map<Key, T, Compare, Allocator>*, 1412 MessageReader*, const void*&, const void*&); 1413template <typename Key, typename T, typename Hash, typename KeyEqual, 1414 typename Allocator> 1415inline ErrorType DeserializeObject( 1416 std::unordered_map<Key, T, Hash, KeyEqual, Allocator>*, MessageReader*, 1417 const void*&, const void*&); 1418template <typename T> 1419inline ErrorType DeserializeObject(ArrayWrapper<T>*, MessageReader*, 1420 const void*&, const void*&); 1421template <typename T, std::size_t Size> 1422inline ErrorType DeserializeObject(std::array<T, Size>*, MessageReader*, 1423 const void*&, const void*&); 1424template <typename T, typename U> 1425inline ErrorType DeserializeObject(std::pair<T, U>*, MessageReader*, 1426 const void*&, const void*&); 1427template <typename... T> 1428inline ErrorType DeserializeObject(std::tuple<T...>*, MessageReader*, 1429 const void*&, const void*&); 1430inline ErrorType DeserializeObject(EmptyVariant*, 1431 MessageReader*, const void*&, 1432 const void*&); 1433template <typename... Types> 1434inline ErrorType DeserializeObject(Variant<Types...>*, 1435 MessageReader*, const void*&, 1436 const void*&); 1437 1438// Deserializes a Serializable type. 1439template <typename T, typename Enable = EnableIfHasSerializableMembers<T>> 1440inline ErrorType DeserializeObject(T* value, MessageReader* reader, 1441 const void*& start, const void*& end) { 1442 return SerializableTraits<T>::DeserializeObject(value, reader, start, end); 1443} 1444 1445// Deserializes a PointerWrapper. 1446template <typename T> 1447inline ErrorType DeserializeObject(PointerWrapper<T>* pointer, 1448 MessageReader* reader, const void*& start, 1449 const void*& end) { 1450 return DeserializeObject(&pointer->Dereference(), reader, start, end); 1451} 1452 1453// Deserializes the type code and size for extension types. 1454inline ErrorType DeserializeExtType(EncodingType* encoding, 1455 EncodingExtType* type, std::size_t* size, 1456 MessageReader* reader, const void*& start, 1457 const void*& end) { 1458 if (const auto error = DeserializeEncoding(encoding, reader, start, end)) { 1459 return error; 1460 } else if (IsFixextEncoding(*encoding)) { 1461 *size = GetFixextSize(*encoding); 1462 } else if (*encoding == ENCODING_TYPE_EXT8) { 1463 if (const auto error = 1464 DeserializeValue<std::uint8_t>(size, reader, start, end)) 1465 return error; 1466 } else if (*encoding == ENCODING_TYPE_EXT16) { 1467 if (const auto error = 1468 DeserializeValue<std::uint16_t>(size, reader, start, end)) 1469 return error; 1470 } else if (*encoding == ENCODING_TYPE_EXT32) { 1471 if (const auto error = 1472 DeserializeValue<std::uint32_t>(size, reader, start, end)) 1473 return error; 1474 } else { 1475 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_EXTENSION, 1476 *encoding); 1477 } 1478 1479 // The extension type code follows the encoding and size. 1480 return DeserializeRaw(type, reader, start, end); 1481} 1482 1483// Deserializes a file handle and performs handle space translation, if 1484// required. 1485inline ErrorType DeserializeObject(LocalHandle* value, MessageReader* reader, 1486 const void*& start, const void*& end) { 1487 EncodingType encoding; 1488 EncodingExtType type; 1489 std::size_t size; 1490 1491 if (const auto error = 1492 DeserializeExtType(&encoding, &type, &size, reader, start, end)) { 1493 return error; 1494 } else if (size != 2) { 1495 return ErrorType(ErrorCode::UNEXPECTED_TYPE_SIZE, ENCODING_CLASS_EXTENSION, 1496 encoding); 1497 } else if (type == ENCODING_EXT_TYPE_FILE_DESCRIPTOR) { 1498 // Read the encoded file descriptor value. 1499 FileReference ref; 1500 if (const auto error = DeserializeRaw(&ref, reader, start, end)) { 1501 return error; 1502 } 1503 1504 return reader->GetInputResourceMapper()->GetFileHandle(ref, value) 1505 ? ErrorCode::NO_ERROR 1506 : ErrorCode::GET_FILE_DESCRIPTOR_FAILED; 1507 } else { 1508 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_EXTENSION, 1509 encoding); 1510 } 1511} 1512 1513inline ErrorType DeserializeObject(LocalChannelHandle* value, 1514 MessageReader* reader, const void*& start, 1515 const void*& end) { 1516 EncodingType encoding; 1517 EncodingExtType type; 1518 std::size_t size; 1519 1520 if (const auto error = 1521 DeserializeExtType(&encoding, &type, &size, reader, start, end)) { 1522 return error; 1523 } else if (size != 4) { 1524 return ErrorType(ErrorCode::UNEXPECTED_TYPE_SIZE, ENCODING_CLASS_EXTENSION, 1525 encoding); 1526 } else if (type == ENCODING_EXT_TYPE_CHANNEL_HANDLE) { 1527 // Read the encoded channel handle value. 1528 ChannelReference ref; 1529 if (const auto error = DeserializeRaw(&ref, reader, start, end)) { 1530 return error; 1531 } 1532 return reader->GetInputResourceMapper()->GetChannelHandle(ref, value) 1533 ? ErrorCode::NO_ERROR 1534 : ErrorCode::GET_CHANNEL_HANDLE_FAILED; 1535 } else { 1536 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_EXTENSION, 1537 encoding); 1538 } 1539} 1540 1541// Deserializes the type code and size for bin types. 1542inline ErrorType DeserializeBinType(EncodingType* encoding, std::size_t* size, 1543 MessageReader* reader, const void*& start, 1544 const void*& end) { 1545 if (const auto error = DeserializeEncoding(encoding, reader, start, end)) { 1546 return error; 1547 } else if (*encoding == ENCODING_TYPE_BIN8) { 1548 return DeserializeValue<std::uint8_t>(size, reader, start, end); 1549 } else if (*encoding == ENCODING_TYPE_BIN16) { 1550 return DeserializeValue<std::uint16_t>(size, reader, start, end); 1551 } else if (*encoding == ENCODING_TYPE_BIN32) { 1552 return DeserializeValue<std::uint32_t>(size, reader, start, end); 1553 } else { 1554 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_BINARY, 1555 *encoding); 1556 } 1557} 1558 1559// Overload of DeserializeObject() for BufferWrapper types. 1560template <typename T, typename Allocator> 1561inline ErrorType DeserializeObject( 1562 BufferWrapper<std::vector<T, Allocator>>* value, MessageReader* reader, 1563 const void*& start, const void*& end) { 1564 const auto value_type_size = 1565 sizeof(typename BufferWrapper<std::vector<T, Allocator>>::value_type); 1566 EncodingType encoding; 1567 std::size_t size; 1568 1569 if (const auto error = 1570 DeserializeBinType(&encoding, &size, reader, start, end)) 1571 return error; 1572 1573 // Try to resize the BufferWrapper to the size of the payload. 1574 value->resize(size / value_type_size); 1575 1576 if (size > value->size() * value_type_size || size % value_type_size != 0) { 1577 return ErrorCode::INSUFFICIENT_DESTINATION_SIZE; 1578 } else if (size == 0U) { 1579 return ErrorCode::NO_ERROR; 1580 } else { 1581 return ReadRawData(value->data(), reader, start, end, size); 1582 } 1583} 1584template <typename T> 1585inline ErrorType DeserializeObject(BufferWrapper<T*>* value, 1586 MessageReader* reader, const void*& start, 1587 const void*& end) { 1588 const auto value_type_size = sizeof(typename BufferWrapper<T*>::value_type); 1589 EncodingType encoding; 1590 std::size_t size; 1591 1592 if (const auto error = 1593 DeserializeBinType(&encoding, &size, reader, start, end)) 1594 return error; 1595 1596 // Try to resize the BufferWrapper to the size of the payload. 1597 value->resize(size / value_type_size); 1598 1599 if (size > value->size() * value_type_size || size % value_type_size != 0) { 1600 return ErrorCode::INSUFFICIENT_DESTINATION_SIZE; 1601 } else if (size == 0U) { 1602 return ErrorCode::NO_ERROR; 1603 } else { 1604 return ReadRawData(value->data(), reader, start, end, size); 1605 } 1606} 1607 1608// Deserializes the type code and size for string types. 1609inline ErrorType DeserializeStringType(EncodingType* encoding, 1610 std::size_t* size, MessageReader* reader, 1611 const void*& start, const void*& end) { 1612 if (const auto error = DeserializeEncoding(encoding, reader, start, end)) { 1613 return error; 1614 } else if (IsFixstrEncoding(*encoding)) { 1615 *size = GetFixstrSize(*encoding); 1616 return ErrorCode::NO_ERROR; 1617 } else if (*encoding == ENCODING_TYPE_STR8) { 1618 return DeserializeValue<std::uint8_t>(size, reader, start, end); 1619 } else if (*encoding == ENCODING_TYPE_STR16) { 1620 return DeserializeValue<std::uint16_t>(size, reader, start, end); 1621 } else if (*encoding == ENCODING_TYPE_STR32) { 1622 return DeserializeValue<std::uint32_t>(size, reader, start, end); 1623 } else { 1624 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_STRING, 1625 *encoding); 1626 } 1627} 1628 1629// Overload of DeserializeObject() for std::string types. 1630inline ErrorType DeserializeObject(std::string* value, MessageReader* reader, 1631 const void*& start, const void*& end) { 1632 EncodingType encoding; 1633 std::size_t size; 1634 1635 if (const auto error = 1636 DeserializeStringType(&encoding, &size, reader, start, end)) { 1637 return error; 1638 } else if (size == 0U) { 1639 value->clear(); 1640 return ErrorCode::NO_ERROR; 1641 } else { 1642 value->resize(size); 1643 return ReadRawData(&(*value)[0], reader, start, end, size); 1644 } 1645} 1646 1647// Overload of DeserializeObject() for StringWrapper types. 1648template <typename T> 1649inline ErrorType DeserializeObject(StringWrapper<T>* value, 1650 MessageReader* reader, const void*& start, 1651 const void*& end) { 1652 const auto value_type_size = sizeof(typename StringWrapper<T>::value_type); 1653 EncodingType encoding; 1654 std::size_t size; 1655 1656 if (const auto error = 1657 DeserializeStringType(&encoding, &size, reader, start, end)) 1658 return error; 1659 1660 // Try to resize the StringWrapper to the size of the payload 1661 // string. 1662 value->resize(size / value_type_size); 1663 1664 if (size > value->length() * value_type_size || size % value_type_size != 0) { 1665 return ErrorCode::INSUFFICIENT_DESTINATION_SIZE; 1666 } else if (size == 0U) { 1667 return ErrorCode::NO_ERROR; 1668 } else { 1669 return ReadRawData(value->data(), reader, start, end, size); 1670 } 1671} 1672 1673// Deserializes the type code and size of array types. 1674inline ErrorType DeserializeArrayType(EncodingType* encoding, std::size_t* size, 1675 MessageReader* reader, const void*& start, 1676 const void*& end) { 1677 if (const auto error = DeserializeEncoding(encoding, reader, start, end)) { 1678 return error; 1679 } else if (IsFixarrayEncoding(*encoding)) { 1680 *size = GetFixarraySize(*encoding); 1681 return ErrorCode::NO_ERROR; 1682 } else if (*encoding == ENCODING_TYPE_ARRAY16) { 1683 return DeserializeValue<std::uint16_t>(size, reader, start, end); 1684 } else if (*encoding == ENCODING_TYPE_ARRAY32) { 1685 return DeserializeValue<std::uint32_t>(size, reader, start, end); 1686 } else { 1687 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_ARRAY, 1688 *encoding); 1689 } 1690} 1691 1692// Deserializes the type code and size of map types. 1693inline ErrorType DeserializeMapType(EncodingType* encoding, std::size_t* size, 1694 MessageReader* reader, const void*& start, 1695 const void*& end) { 1696 if (const auto error = DeserializeEncoding(encoding, reader, start, end)) { 1697 return error; 1698 } else if (IsFixmapEncoding(*encoding)) { 1699 *size = GetFixmapSize(*encoding); 1700 return ErrorCode::NO_ERROR; 1701 } else if (*encoding == ENCODING_TYPE_MAP16) { 1702 return DeserializeValue<std::uint16_t>(size, reader, start, end); 1703 } else if (*encoding == ENCODING_TYPE_MAP32) { 1704 return DeserializeValue<std::uint32_t>(size, reader, start, end); 1705 } else { 1706 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_MAP, 1707 *encoding); 1708 } 1709} 1710 1711// Overload for std::vector types. 1712template <typename T, typename Allocator> 1713inline ErrorType DeserializeObject(std::vector<T, Allocator>* value, 1714 MessageReader* reader, const void*& start, 1715 const void*& end) { 1716 EncodingType encoding; 1717 std::size_t size; 1718 1719 if (const auto error = 1720 DeserializeArrayType(&encoding, &size, reader, start, end)) 1721 return error; 1722 1723 std::vector<T, Allocator> result(size); 1724 for (std::size_t i = 0; i < size; i++) { 1725 if (const auto error = DeserializeObject(&result[i], reader, start, end)) 1726 return error; 1727 } 1728 1729 *value = std::move(result); 1730 return ErrorCode::NO_ERROR; 1731 1732// TODO(eieio): Consider the benefits and trade offs of this alternative. 1733#if 0 1734 value->resize(size); 1735 for (std::size_t i = 0; i < size; i++) { 1736 if (const auto error = DeserializeObject(&(*value)[i], reader, start, end)) 1737 return error; 1738 } 1739 return ErrorCode::NO_ERROR; 1740#endif 1741} 1742 1743// Deserializes an EmptyVariant value. 1744inline ErrorType DeserializeObject(EmptyVariant* /*empty*/, 1745 MessageReader* reader, const void*& start, 1746 const void*& end) { 1747 EncodingType encoding; 1748 1749 if (const auto error = DeserializeEncoding(&encoding, reader, start, end)) { 1750 return error; 1751 } else if (encoding != ENCODING_TYPE_NIL) { 1752 return ErrorType(ErrorCode::UNEXPECTED_ENCODING, ENCODING_CLASS_MAP, 1753 encoding); 1754 } else { 1755 return ErrorCode::NO_ERROR; 1756 } 1757} 1758 1759// Deserializes a Variant type. 1760template <typename... Types> 1761inline ErrorType DeserializeObject(Variant<Types...>* variant, 1762 MessageReader* reader, const void*& start, 1763 const void*& end) { 1764 EncodingType encoding; 1765 std::size_t size; 1766 1767 if (const auto error = 1768 DeserializeMapType(&encoding, &size, reader, start, end)) { 1769 return error; 1770 } 1771 1772 if (size != 1) 1773 return ErrorType(ErrorCode::UNEXPECTED_TYPE_SIZE, ENCODING_CLASS_MAP, 1774 encoding); 1775 1776 std::int32_t type; 1777 if (const auto error = DeserializeObject(&type, reader, start, end)) { 1778 return error; 1779 } else if (type < Variant<Types...>::kEmptyIndex || 1780 type >= static_cast<std::int32_t>(sizeof...(Types))) { 1781 return ErrorCode::INVALID_VARIANT_ELEMENT; 1782 } else { 1783 variant->Become(type); 1784 return variant->Visit([reader, &start, &end](auto&& value) { 1785 return DeserializeObject(&value, reader, start, end); 1786 }); 1787 } 1788} 1789 1790// Deserializes map types. 1791template <typename MapType> 1792inline ErrorType DeserializeMap(MapType* value, MessageReader* reader, 1793 const void*& start, const void*& end) { 1794 EncodingType encoding; 1795 std::size_t size; 1796 1797 if (const auto error = 1798 DeserializeMapType(&encoding, &size, reader, start, end)) 1799 return error; 1800 1801 MapType result; 1802 for (std::size_t i = 0; i < size; i++) { 1803 std::pair<typename MapType::key_type, typename MapType::mapped_type> 1804 element; 1805 if (const auto error = 1806 DeserializeObject(&element.first, reader, start, end)) 1807 return error; 1808 if (const auto error = 1809 DeserializeObject(&element.second, reader, start, end)) 1810 return error; 1811 result.emplace(std::move(element)); 1812 } 1813 1814 *value = std::move(result); 1815 return ErrorCode::NO_ERROR; 1816} 1817 1818// Overload for std::map types. 1819template <typename Key, typename T, typename Compare, typename Allocator> 1820inline ErrorType DeserializeObject(std::map<Key, T, Compare, Allocator>* value, 1821 MessageReader* reader, const void*& start, 1822 const void*& end) { 1823 return DeserializeMap(value, reader, start, end); 1824} 1825 1826// Overload for std::unordered_map types. 1827template <typename Key, typename T, typename Hash, typename KeyEqual, 1828 typename Allocator> 1829inline ErrorType DeserializeObject( 1830 std::unordered_map<Key, T, Hash, KeyEqual, Allocator>* value, 1831 MessageReader* reader, const void*& start, const void*& end) { 1832 return DeserializeMap(value, reader, start, end); 1833} 1834 1835// Overload for ArrayWrapper types. 1836template <typename T> 1837inline ErrorType DeserializeObject(ArrayWrapper<T>* value, 1838 MessageReader* reader, const void*& start, 1839 const void*& end) { 1840 EncodingType encoding; 1841 std::size_t size; 1842 1843 if (const auto error = 1844 DeserializeArrayType(&encoding, &size, reader, start, end)) { 1845 return error; 1846 } 1847 1848 // Try to resize the wrapper. 1849 value->resize(size); 1850 1851 // Make sure there is enough space in the ArrayWrapper for the 1852 // payload. 1853 if (size > value->capacity()) 1854 return ErrorCode::INSUFFICIENT_DESTINATION_SIZE; 1855 1856 for (std::size_t i = 0; i < size; i++) { 1857 if (const auto error = DeserializeObject(&(*value)[i], reader, start, end)) 1858 return error; 1859 } 1860 1861 return ErrorCode::NO_ERROR; 1862} 1863 1864// Overload for std::array types. 1865template <typename T, std::size_t Size> 1866inline ErrorType DeserializeObject(std::array<T, Size>* value, 1867 MessageReader* reader, const void*& start, 1868 const void*& end) { 1869 EncodingType encoding; 1870 std::size_t size; 1871 1872 if (const auto error = 1873 DeserializeArrayType(&encoding, &size, reader, start, end)) { 1874 return error; 1875 } 1876 1877 if (size != Size) 1878 return ErrorCode::INSUFFICIENT_DESTINATION_SIZE; 1879 1880 for (std::size_t i = 0; i < size; i++) { 1881 if (const auto error = DeserializeObject(&(*value)[i], reader, start, end)) 1882 return error; 1883 } 1884 1885 return ErrorCode::NO_ERROR; 1886} 1887 1888// Deserializes std::pair types. 1889template <typename T, typename U> 1890inline ErrorType DeserializeObject(std::pair<T, U>* value, 1891 MessageReader* reader, const void*& start, 1892 const void*& end) { 1893 EncodingType encoding; 1894 std::size_t size; 1895 1896 if (const auto error = 1897 DeserializeArrayType(&encoding, &size, reader, start, end)) { 1898 return error; 1899 } else if (size != 2) { 1900 return ErrorCode::UNEXPECTED_TYPE_SIZE; 1901 } else if (const auto error = 1902 DeserializeObject(&value->first, reader, start, end)) { 1903 return error; 1904 } else if (const auto error = 1905 DeserializeObject(&value->second, reader, start, end)) { 1906 return error; 1907 } else { 1908 return ErrorCode::NO_ERROR; 1909 } 1910} 1911 1912// Stops template recursion when the last tuple element is reached. 1913template <typename... T> 1914inline ErrorType DeserializeTuple(std::tuple<T...>*, MessageReader*, 1915 const void*&, const void*, Index<0>) { 1916 return ErrorCode::NO_ERROR; 1917} 1918 1919// Deserializes each element of a tuple recursively. 1920template <typename... T, std::size_t index> 1921inline ErrorType DeserializeTuple(std::tuple<T...>* tuple, 1922 MessageReader* reader, const void*& start, 1923 const void*& end, Index<index>) { 1924 if (const auto error = 1925 DeserializeTuple(tuple, reader, start, end, Index<index - 1>())) 1926 return error; 1927 else 1928 return DeserializeObject(&std::get<index - 1>(*tuple), reader, start, end); 1929} 1930 1931// Overload for standard tuple types. 1932template <typename... T> 1933inline ErrorType DeserializeObject(std::tuple<T...>* value, 1934 MessageReader* reader, const void*& start, 1935 const void*& end) { 1936 EncodingType encoding; 1937 std::size_t size; 1938 1939 if (const auto error = 1940 DeserializeArrayType(&encoding, &size, reader, start, end)) { 1941 return error; 1942 } else if (size != sizeof...(T)) { 1943 return ErrorCode::UNEXPECTED_TYPE_SIZE; 1944 } else { 1945 return DeserializeTuple(value, reader, start, end, Index<sizeof...(T)>()); 1946 } 1947} 1948 1949// Stops template recursion when the last member of a Serializable type is 1950// reached. 1951template <typename Members, typename T> 1952inline ErrorType DeserializeMember(T*, MessageReader*, const void*&, 1953 const void*, Index<0>) { 1954 return ErrorCode::NO_ERROR; 1955} 1956 1957// Deserializes each member of a Serializable type recursively. 1958template <typename Members, typename T, std::size_t index> 1959inline ErrorType DeserializeMember(T* value, MessageReader* reader, 1960 const void*& start, const void*& end, 1961 Index<index>) { 1962 if (const auto error = DeserializeMember<Members>(value, reader, start, end, 1963 Index<index - 1>())) 1964 return error; 1965 else 1966 return DeserializeObject(&Members::template At<index - 1>::Resolve(*value), 1967 reader, start, end); 1968} 1969 1970// Deserializes the members of a Serializable type using the given 1971// SerializableMembersType type. 1972template <typename Members, typename T> 1973inline ErrorType DeserializeMembers(T* value, MessageReader* reader, 1974 const void*& start, const void*& end) { 1975 return DeserializeMember<Members>(value, reader, start, end, 1976 Index<Members::MemberCount>()); 1977} 1978 1979// Top level deserialization function. 1980template <typename T> 1981inline ErrorType Deserialize(T* value, MessageReader* reader) { 1982 PDX_TRACE_NAME("Deserialize"); 1983 MessageReader::BufferSection section = reader->GetNextReadBufferSection(); 1984 if (section.first == section.second) 1985 return ErrorCode::INSUFFICIENT_BUFFER; 1986 ErrorType error = 1987 DeserializeObject(value, reader, section.first, section.second); 1988 reader->ConsumeReadBufferSectionData(section.first); 1989 return error; 1990} 1991 1992} // namespace rpc 1993} // namespace pdx 1994} // namespace android 1995 1996#endif // ANDROID_PDX_RPC_SERIALIZATION_H_ 1997