Cross Reference: /frameworks/native/libs/vr/libpdx/private/pdx/rpc/serialization.h

Lines Matching defs:std
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
57 //   * std::array with values of any supported type, including nesting.
64 //   * std::basic_string with all supported char types.
67 template <std::size_t N>
80 std::true_type DeduceTemplateType(const TT<Ts...>*);
82 std::false_type DeduceTemplateType(...);
86 using IsTemplateBaseOf = decltype(DeduceTemplateType<TT>(std::declval<T*>()));
95 struct HasSerializableMembers : std::false_type {};
99     : std::integral_constant<
107     typename std::enable_if<HasSerializableMembers<T>::value>::type;
112     typename std::enable_if<std::is_enum<T>::value, ReturnType>::type;
162   operator std::string() const {
163     std::ostringstream stream;
200 inline constexpr std::size_t GetSerializedSize(const bool& b) {
205 inline constexpr std::size_t GetSerializedSize(const char& c) {
208 inline constexpr std::size_t GetSerializedSize(const std::uint8_t& i) {
211 inline constexpr std::size_t GetSerializedSize(const std::int8_t& i) {
214 inline constexpr std::size_t GetSerializedSize(const std::uint16_t& i) {
217 inline constexpr std::size_t GetSerializedSize(const std::int16_t& i) {
220 inline constexpr std::size_t GetSerializedSize(const std::uint32_t& i) {
223 inline constexpr std::size_t GetSerializedSize(const std::int32_t& i) {
226 inline constexpr std::size_t GetSerializedSize(const std::uint64_t& i) {
229 inline constexpr std::size_t GetSerializedSize(const std::int64_t& i) {
233 inline constexpr std::size_t GetSerializedSize(const float& f) {
236 inline constexpr std::size_t GetSerializedSize(const double& d) {
242 inline EnableIfEnum<T, std::size_t> GetSerializedSize(T v) {
243   return GetSerializedSize(static_cast<std::underlying_type_t<T>>(v));
247 inline std::size_t GetSerializedSize(const EmptyVariant&);
249 inline std::size_t GetSerializedSize(const Variant<Types...>&);
251 inline constexpr std::size_t GetSerializedSize(const T&);
253 inline constexpr std::size_t GetSerializedSize(const PointerWrapper<T>&);
254 inline constexpr std::size_t GetSerializedSize(const std::string&);
256 inline constexpr std::size_t GetSerializedSize(const StringWrapper<T>&);
258 inline constexpr std::size_t GetSerializedSize(const BufferWrapper<T>&);
260 inline constexpr std::size_t GetSerializedSize(const FileHandle<Mode>&);
262 inline constexpr std::size_t GetSerializedSize(const ChannelHandle<Mode>&);
264 inline std::size_t GetSerializedSize(const std::vector<T, Allocator>& v);
266 inline std::size_t GetSerializedSize(
267     const std::map<Key, T, Compare, Allocator>& m);
270 inline std::size_t GetSerializedSize(
271     const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>&);
273 inline std::size_t GetSerializedSize(const ArrayWrapper<T>&);
274 template <typename T, std::size_t Size>
275 inline std::size_t GetSerializedSize(const std::array<T, Size>& v);
277 inline std::size_t GetSerializedSize(const std::pair<T, U>& p);
279 inline std::size_t GetSerializedSize(const std::tuple<T...>& tuple);
282 inline std::size_t GetSerializedSize(const EmptyVariant& empty) {
288 inline std::size_t GetSerializedSize(const Variant<Types...>& variant) {
297 inline constexpr std::size_t GetSerializedSize(const T& value) {
303 inline constexpr std::size_t GetSerializedSize(const PointerWrapper<T>& p) {
307 // Overload for std::string.
308 inline constexpr std::size_t GetSerializedSize(const std::string& s) {
310          s.length() * sizeof(std::string::value_type);
315 inline constexpr std::size_t GetSerializedSize(const StringWrapper<T>& s) {
322 inline constexpr std::size_t GetSerializedSize(const BufferWrapper<T>& b) {
331 inline constexpr std::size_t GetSerializedSize(const FileHandle<Mode>& fd) {
332   return GetEncodingSize(EncodeType(fd)) + sizeof(std::int16_t);
339 inline constexpr std::size_t GetSerializedSize(
341   return GetEncodingSize(EncodeType(channel_handle)) + sizeof(std::int32_t);
346 inline 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) {
355 inline std::size_t GetSerializedSize(
356     const std::map<Key, T, Compare, Allocator>& v) {
357   return std::accumulate(
359       [](const std::size_t& sum, const std::pair<Key, T>& object) {
368 inline std::size_t GetSerializedSize(
369     const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& v) {
370   return std::accumulate(
372       [](const std::size_t& sum, const std::pair<Key, T>& object) {
380 inline 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) {
387 // Overload for std::array types.
388 template <typename T, std::size_t Size>
389 inline 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) {
396 // Overload for std::pair.
398 inline std::size_t GetSerializedSize(const std::pair<T, U>& p) {
405 inline std::size_t GetTupleSize(const std::tuple<T...>&, Index<0>) {
410 template <typename... T, std::size_t index>
411 inline std::size_t GetTupleSize(const std::tuple<T...>& tuple, Index<index>) {
413          GetSerializedSize(std::get<index - 1>(tuple));
419 inline std::size_t GetSerializedSize(const std::tuple<T...>& tuple) {
427 inline std::size_t GetMemberSize(const T&, Index<0>) {
432 template <typename Members, typename T, std::size_t index>
433 inline std::size_t GetMemberSize(const T& object, Index<index>) {
441 inline std::size_t GetMembersSize(const T& object) {
463           typename = typename std::enable_if<std::is_pod<T>::value>::type>
480                                  EncodingExtType ext_type, std::size_t size,
484     std::uint8_t length = size;
487     std::uint16_t length = size;
490     std::uint32_t length = size;
525     std::uint8_t length = value.length();
528     std::uint16_t length = value.length();
531     std::uint32_t length = value.length();
538 // Serializes the type code for std::string and StringWrapper. These types are
540 inline void SerializeType(const std::string& value, void*& buffer) {
549 inline void SerializeBinEncoding(EncodingType encoding, std::size_t size,
553     std::uint8_t length = size;
556     std::uint16_t length = size;
559     std::uint32_t length = size;
576 inline void SerializeArrayEncoding(EncodingType encoding, std::size_t size,
580     std::uint16_t length = size;
583     std::uint32_t length = size;
591 inline void SerializeMapEncoding(EncodingType encoding, std::size_t size,
595     std::uint16_t length = size;
598     std::uint32_t length = size;
607 inline void SerializeArrayType(const ArrayType& value, std::size_t size,
615 inline void SerializeMapType(const MapType& value, std::size_t size,
621 // Serializes the type code for std::vector and ArrayWrapper. These types are
624 inline void SerializeType(const std::vector<T, Allocator>& value,
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
636 template <typename T, std::size_t Size>
637 inline void SerializeType(const std::array<T, Size>& value, void*& buffer) {
641 // Serializes the type code for std::map types.
643 inline void SerializeType(const std::map<Key, T, Compare, Allocator>& value,
648 // Serializes the type code for std::unordered_map types.
652     const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& value,
657 // Serializes the type code for std::pair types.
659 inline void SerializeType(const std::pair<T, U>& value, void*& buffer) {
663 // Serializes the type code for std::tuple types.
665 inline void SerializeType(const std::tuple<T...>& value, void*& buffer) {
831   SerializeObject(static_cast<std::underlying_type_t<T>>(value), writer,
848 inline void SerializeObject(const BufferWrapper<std::vector<T, Allocator>>&, MessageWriter*, void*&);
851 inline void SerializeObject(const std::string&, MessageWriter*, void*&);
855 inline void SerializeObject(const std::vector<T, Allocator>&, MessageWriter*, void*&);
858 template <typename T, std::size_t Size>
859 inline void SerializeObject(const std::array<T, Size>&, MessageWriter*, void*&);
861 inline void SerializeObject(const std::map<Key, T, Compare, Allocator>&, MessageWriter*, void*&);
865     const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>&, MessageWriter*, void*&);
867 inline void SerializeObject(const std::pair<T, U>&, MessageWriter*, void*&);
869 inline void SerializeObject(const std::tuple<T...>&, MessageWriter*, void*&);
927 inline void SerializeObject(const BufferWrapper<std::vector<T, Allocator>>& b,
930       sizeof(typename BufferWrapper<std::vector<T, Allocator>>::value_type);
950 // Overload of SerializeObject() for std::string and StringWrapper. These types
952 inline void SerializeObject(const std::string& s, MessageWriter* /*writer*/,
982 // Overload of SerializeObject() for std::vector and ArrayWrapper types. These
985 inline void SerializeObject(const std::vector<T, Allocator>& v,
995 // Overload of SerializeObject() for std::array types. These types serialize to
996 // the same format at std::vector and ArrayWrapper and are interchangeable in
998 template <typename T, std::size_t Size>
999 inline void SerializeObject(const std::array<T, Size>& v, MessageWriter* writer,
1004 // Overload of SerializeObject() for std::map types.
1006 inline void SerializeObject(const std::map<Key, T, Compare, Allocator>& v,
1011 // Overload of SerializeObject() for std::unordered_map types.
1015     const std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& v,
1020 // Overload of SerializeObject() for std:pair types.
1022 inline void SerializeObject(const std::pair<T, U>& pair, MessageWriter* writer,
1031 inline void SerializeTuple(const std::tuple<T...>&, MessageWriter*, void*&,
1035 template <typename... T, std::size_t index>
1036 inline void SerializeTuple(const std::tuple<T...>& tuple, MessageWriter* writer,
1039   SerializeObject(std::get<index - 1>(tuple), writer, buffer);
1044 inline void SerializeObject(const std::tuple<T...>& tuple,
1055 template <typename Members, typename T, std::size_t index>
1076   const std::size_t size = GetSerializedSize(object);
1098     std::tie(start, end) = reader->GetNextReadBufferSection();
1128           typename = typename std::enable_if<std::is_pod<T>::value>::type>
1217 inline ErrorType DeserializeObject(std::int8_t* value, MessageReader* reader,
1223     *value = static_cast<std::int8_t>(encoding);
1226     return DeserializeValue<std::int8_t>(value, reader, start, end);
1233 inline ErrorType DeserializeObject(std::uint8_t* value, MessageReader* reader,
1242     return DeserializeValue<std::uint8_t>(value, reader, start, end);
1249 inline ErrorType DeserializeObject(std::int16_t* value, MessageReader* reader,
1255     *value = static_cast<std::int8_t>(encoding);
1258     return DeserializeValue<std::int8_t>(value, reader, start, end);
1260     return DeserializeValue<std::int16_t>(value, reader, start, end);
1267 inline ErrorType DeserializeObject(std::uint16_t* value, MessageReader* reader,
1276     return DeserializeValue<std::uint8_t>(value, reader, start, end);
1278     return DeserializeValue<std::uint16_t>(value, reader, start, end);
1285 inline ErrorType DeserializeObject(std::int32_t* value, MessageReader* reader,
1291     *value = static_cast<std::int8_t>(encoding);
1294     return DeserializeValue<std::int8_t>(value, reader, start, end);
1296     return DeserializeValue<std::int16_t>(value, reader, start, end);
1298     return DeserializeValue<std::int32_t>(value, reader, start, end);
1305 inline ErrorType DeserializeObject(std::uint32_t* value, MessageReader* reader,
1314     return DeserializeValue<std::uint8_t>(value, reader, start, end);
1316     return DeserializeValue<std::uint16_t>(value, reader, start, end);
1318     return DeserializeValue<std::uint32_t>(value, reader, start, end);
1325 inline ErrorType DeserializeObject(std::int64_t* value, MessageReader* reader,
1331     *value = static_cast<std::int8_t>(encoding);
1334     return DeserializeValue<std::int8_t>(value, reader, start, end);
1336     return DeserializeValue<std::int16_t>(value, reader, start, end);
1338     return DeserializeValue<std::int32_t>(value, reader, start, end);
1340     return DeserializeValue<std::int64_t>(value, reader, start, end);
1347 inline ErrorType DeserializeObject(std::uint64_t* value, MessageReader* reader,
1356     return DeserializeValue<std::uint8_t>(value, reader, start, end);
1358     return DeserializeValue<std::uint16_t>(value, reader, start, end);
1360     return DeserializeValue<std::uint32_t>(value, reader, start, end);
1362     return DeserializeValue<std::uint64_t>(value, reader, start, end);
1374   std::underlying_type_t<T> enum_value;
1393 inline ErrorType DeserializeObject(BufferWrapper<std::vector<T, Allocator>>*,
1398 inline ErrorType DeserializeObject(std::string*, MessageReader*, const void*&,
1404 inline ErrorType DeserializeObject(std::pair<T, U>*, MessageReader*,
1407 inline ErrorType DeserializeObject(std::tuple<T...>*, MessageReader*,
1410 inline ErrorType DeserializeObject(std::vector<T, Allocator>*, MessageReader*,
1413 inline ErrorType DeserializeObject(std::map<Key, T, Compare, Allocator>*,
1418     std::unordered_map<Key, T, Hash, KeyEqual, Allocator>*, MessageReader*,
1423 template <typename T, std::size_t Size>
1424 inline ErrorType DeserializeObject(std::array<T, Size>*, MessageReader*,
1427 inline ErrorType DeserializeObject(std::pair<T, U>*, MessageReader*,
1430 inline ErrorType DeserializeObject(std::tuple<T...>*, MessageReader*,
1457                                     EncodingExtType* type, std::size_t* size,
1466             DeserializeValue<std::uint8_t>(size, reader, start, end))
1470             DeserializeValue<std::uint16_t>(size, reader, start, end))
1474             DeserializeValue<std::uint32_t>(size, reader, start, end))
1491   std::size_t size;
1520   std::size_t size;
1544 inline ErrorType DeserializeBinType(EncodingType* encoding, std::size_t* size,
1550     return DeserializeValue<std::uint8_t>(size, reader, start, end);
1552     return DeserializeValue<std::uint16_t>(size, reader, start, end);
1554     return DeserializeValue<std::uint32_t>(size, reader, start, end);
1564     BufferWrapper<std::vector<T, Allocator>>* value, MessageReader* reader,
1567       sizeof(typename BufferWrapper<std::vector<T, Allocator>>::value_type);
1569   std::size_t size;
1592   std::size_t size;
1612                                        std::size_t* size, MessageReader* reader,
1620     return DeserializeValue<std::uint8_t>(size, reader, start, end);
1622     return DeserializeValue<std::uint16_t>(size, reader, start, end);
1624     return DeserializeValue<std::uint32_t>(size, reader, start, end);
1631 // Overload of DeserializeObject() for std::string types.
1632 inline ErrorType DeserializeObject(std::string* value, MessageReader* reader,
1635   std::size_t size;
1656   std::size_t size;
1676 inline ErrorType DeserializeArrayType(EncodingType* encoding, std::size_t* size,
1685     return DeserializeValue<std::uint16_t>(size, reader, start, end);
1687     return DeserializeValue<std::uint32_t>(size, reader, start, end);
1695 inline ErrorType DeserializeMapType(EncodingType* encoding, std::size_t* size,
1704     return DeserializeValue<std::uint16_t>(size, reader, start, end);
1706     return DeserializeValue<std::uint32_t>(size, reader, start, end);
1713 // Overload for std::vector types.
1715 inline ErrorType DeserializeObject(std::vector<T, Allocator>* value,
1719   std::size_t size;
1725   std::vector<T, Allocator> result(size);
1726   for (std::size_t i = 0; i < size; i++) {
1731   *value = std::move(result);
1737   for (std::size_t i = 0; i < size; i++) {
1767   std::size_t size;
1778   std::int32_t type;
1782              type >= static_cast<std::int32_t>(sizeof...(Types))) {
1797   std::size_t size;
1804   for (std::size_t i = 0; i < size; i++) {
1805     std::pair<typename MapType::key_type, typename MapType::mapped_type>
1813     result.emplace(std::move(element));
1816   *value = std::move(result);
1820 // Overload for std::map types.
1822 inline ErrorType DeserializeObject(std::map<Key, T, Compare, Allocator>* value,
1828 // Overload for std::unordered_map types.
1832     std::unordered_map<Key, T, Hash, KeyEqual, Allocator>* value,
1843   std::size_t size;
1858   for (std::size_t i = 0; i < size; i++) {
1866 // Overload for std::array types.
1867 template <typename T, std::size_t Size>
1868 inline ErrorType DeserializeObject(std::array<T, Size>* value,
1872   std::size_t size;
1882   for (std::size_t i = 0; i < size; i++) {
1890 // Deserializes std::pair types.
1892 inline ErrorType DeserializeObject(std::pair<T, U>* value,
1896   std::size_t size;
1916 inline ErrorType DeserializeTuple(std::tuple<T...>*, MessageReader*,
1922 template <typename... T, std::size_t index>
1923 inline ErrorType DeserializeTuple(std::tuple<T...>* tuple,
1930     return DeserializeObject(&std::get<index - 1>(*tuple), reader, start, end);
1935 inline ErrorType DeserializeObject(std::tuple<T...>* value,
1939   std::size_t size;
1960 template <typename Members, typename T, std::size_t index>