ikan Uploader :
Directory : /home/ubuntu/node-v16.18.1/deps/v8/third_party/inspector_protocol/crdtp/
Upload File : |
| Current File : //home/ubuntu/node-v16.18.1/deps/v8/third_party/inspector_protocol/crdtp/serializer_traits.h |
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_CRDTP_SERIALIZER_TRAITS_H_
#define V8_CRDTP_SERIALIZER_TRAITS_H_
#include <memory>
#include <string>
#include <vector>
#include "cbor.h"
#include "maybe.h"
#include "span.h"
namespace v8_crdtp {
// =============================================================================
// SerializerTraits - Encodes field values of protocol objects in CBOR.
// =============================================================================
//
// A family of serialization functions which are used by FieldSerializerTraits
// (below) to encode field values in CBOR. Conceptually, it's this:
//
// Serialize(bool value, std::vector<uint8_t>* out);
// Serialize(int32_t value, std::vector<uint8_t>* out);
// Serialize(double value, std::vector<uint8_t>* out);
// ...
//
// However, if this was to use straight-forward overloading, implicit
// type conversions would lead to ambiguity - e.g., a bool could be
// represented as an int32_t, but it should really be encoded as a bool.
// The template parameterized / specialized structs accomplish this.
//
// SerializerTraits<bool>::Serialize(bool value, std::vector<uint8_t>* out);
// SerializerTraits<int32>::Serialize(int32_t value, std::vector<uint8_t>* out);
// SerializerTraits<double>::Serialize(double value, std::vector<uint8_t>* out);
template <typename T>
struct SerializerTraits {
// |Serializable| (defined in serializable.h) already knows how to serialize
// to CBOR, so we can just delegate. This covers domain specific types,
// protocol::Binary, etc.
// However, we use duck-typing here, because Exported, which is part of the V8
// headers also comes with AppendSerialized, and logically it's the same type,
// but it lives in a different namespace (v8_inspector::protocol::Exported).
template <
typename LikeSerializable,
typename std::enable_if_t<std::is_member_pointer<decltype(
&LikeSerializable::AppendSerialized)>{},
int> = 0>
static void Serialize(const LikeSerializable& value,
std::vector<uint8_t>* out) {
value.AppendSerialized(out);
}
};
// This covers std::string, which is assumed to be UTF-8.
// The two other string implementations that are used in the protocol bindings:
// - WTF::String, for which the SerializerTraits specialization is located
// in third_party/blink/renderer/core/inspector/v8-inspector-string.h.
// - v8_inspector::String16, implemented in v8/src/inspector/string-16.h
// along with its SerializerTraits specialization.
template <>
struct SerializerTraits<std::string> {
static void Serialize(const std::string& str, std::vector<uint8_t>* out) {
cbor::EncodeString8(SpanFrom(str), out);
}
};
template <>
struct SerializerTraits<bool> {
static void Serialize(bool value, std::vector<uint8_t>* out) {
out->push_back(value ? cbor::EncodeTrue() : cbor::EncodeFalse());
}
};
template <>
struct SerializerTraits<int32_t> {
static void Serialize(int32_t value, std::vector<uint8_t>* out) {
cbor::EncodeInt32(value, out);
}
};
template <>
struct SerializerTraits<double> {
static void Serialize(double value, std::vector<uint8_t>* out) {
cbor::EncodeDouble(value, out);
}
};
template <typename T>
struct SerializerTraits<std::vector<T>> {
static void Serialize(const std::vector<T>& value,
std::vector<uint8_t>* out) {
out->push_back(cbor::EncodeIndefiniteLengthArrayStart());
for (const T& element : value)
SerializerTraits<T>::Serialize(element, out);
out->push_back(cbor::EncodeStop());
}
};
template <typename T>
struct SerializerTraits<std::unique_ptr<T>> {
static void Serialize(const std::unique_ptr<T>& value,
std::vector<uint8_t>* out) {
SerializerTraits<T>::Serialize(*value, out);
}
};
// =============================================================================
// FieldSerializerTraits - Encodes fields of protocol objects in CBOR
// =============================================================================
//
// The generated code (see TypeBuilder_cpp.template) invokes SerializeField,
// which then instantiates the FieldSerializerTraits to emit the appropriate
// existence checks / dereference for the field value. This avoids emitting
// the field name if the value for an optional field isn't set.
template <typename T>
struct FieldSerializerTraits {
static void Serialize(span<uint8_t> field_name,
const T& field_value,
std::vector<uint8_t>* out) {
cbor::EncodeString8(field_name, out);
SerializerTraits<T>::Serialize(field_value, out);
}
};
template <typename T>
struct FieldSerializerTraits<detail::PtrMaybe<T>> {
static void Serialize(span<uint8_t> field_name,
const detail::PtrMaybe<T>& field_value,
std::vector<uint8_t>* out) {
if (!field_value.isJust())
return;
cbor::EncodeString8(field_name, out);
SerializerTraits<T>::Serialize(*field_value.fromJust(), out);
}
};
template <typename T>
struct FieldSerializerTraits<detail::ValueMaybe<T>> {
static void Serialize(span<uint8_t> field_name,
const detail::ValueMaybe<T>& field_value,
std::vector<uint8_t>* out) {
if (!field_value.isJust())
return;
cbor::EncodeString8(field_name, out);
SerializerTraits<T>::Serialize(field_value.fromJust(), out);
}
};
template <typename T>
void SerializeField(span<uint8_t> field_name,
const T& field_value,
std::vector<uint8_t>* out) {
FieldSerializerTraits<T>::Serialize(field_name, field_value, out);
}
} // namespace v8_crdtp
#endif // V8_CRDTP_SERIALIZER_TRAITS_H_
Kontol Shell Bypass