#[derive(Debug, Clone, serde::Serialize)]
pub struct AddInspectedHeapObjectParams {
#[serde(rename = "heapObjectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub heap_object_id: crate::heap_profiler::types::HeapSnapshotObjectId,
}
impl<'de> serde::Deserialize<'de> for AddInspectedHeapObjectParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddInspectedHeapObjectParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "heapObjectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub heap_object_id: crate::heap_profiler::types::HeapSnapshotObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddInspectedHeapObjectParams {
heap_object_id: fields.heap_object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddInspectedHeapObject;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddInspectedHeapObjectResponse {}
impl<'de> serde::Deserialize<'de> for AddInspectedHeapObjectResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddInspectedHeapObjectResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddInspectedHeapObjectResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddInspectedHeapObject {
type Params = AddInspectedHeapObjectParams;
type Response = AddInspectedHeapObjectResponse;
const METHOD: &'static str = "HeapProfiler.addInspectedHeapObject";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct CollectGarbageParams {}
impl<'de> serde::Deserialize<'de> for CollectGarbageParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CollectGarbageParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CollectGarbageParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CollectGarbage;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CollectGarbageResponse {}
impl<'de> serde::Deserialize<'de> for CollectGarbageResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CollectGarbageResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CollectGarbageResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CollectGarbage {
type Params = CollectGarbageParams;
type Response = CollectGarbageResponse;
const METHOD: &'static str = "HeapProfiler.collectGarbage";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct DisableParams {}
impl<'de> serde::Deserialize<'de> for DisableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DisableParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Disable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DisableResponse {}
impl<'de> serde::Deserialize<'de> for DisableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DisableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Disable {
type Params = DisableParams;
type Response = DisableResponse;
const METHOD: &'static str = "HeapProfiler.disable";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct EnableParams {}
impl<'de> serde::Deserialize<'de> for EnableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Enable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct EnableResponse {}
impl<'de> serde::Deserialize<'de> for EnableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Enable {
type Params = EnableParams;
type Response = EnableResponse;
const METHOD: &'static str = "HeapProfiler.enable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetHeapObjectIdParams {
#[serde(rename = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::runtime::types::RemoteObjectId,
}
impl<'de> serde::Deserialize<'de> for GetHeapObjectIdParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetHeapObjectIdParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::runtime::types::RemoteObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetHeapObjectIdParams {
object_id: fields.object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetHeapObjectId;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetHeapObjectIdResponse {
#[serde(rename = "heapSnapshotObjectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub heap_snapshot_object_id: crate::heap_profiler::types::HeapSnapshotObjectId,
}
impl<'de> serde::Deserialize<'de> for GetHeapObjectIdResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetHeapObjectIdResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "heapSnapshotObjectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub heap_snapshot_object_id: crate::heap_profiler::types::HeapSnapshotObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetHeapObjectIdResponse {
heap_snapshot_object_id: fields.heap_snapshot_object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetHeapObjectId {
type Params = GetHeapObjectIdParams;
type Response = GetHeapObjectIdResponse;
const METHOD: &'static str = "HeapProfiler.getHeapObjectId";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetObjectByHeapObjectIdParams {
#[serde(rename = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::heap_profiler::types::HeapSnapshotObjectId,
#[serde(rename = "objectGroup")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_group: Option<String>,
}
impl<'de> serde::Deserialize<'de> for GetObjectByHeapObjectIdParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetObjectByHeapObjectIdParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::heap_profiler::types::HeapSnapshotObjectId,
#[serde(rename = "objectGroup")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub object_group: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetObjectByHeapObjectIdParams {
object_id: fields.object_id,
object_group: fields.object_group,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetObjectByHeapObjectId;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetObjectByHeapObjectIdResponse {
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: crate::runtime::types::RemoteObject,
}
impl<'de> serde::Deserialize<'de> for GetObjectByHeapObjectIdResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetObjectByHeapObjectIdResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "result")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub result: crate::runtime::types::RemoteObject,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetObjectByHeapObjectIdResponse {
result: fields.result,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetObjectByHeapObjectId {
type Params = GetObjectByHeapObjectIdParams;
type Response = GetObjectByHeapObjectIdResponse;
const METHOD: &'static str = "HeapProfiler.getObjectByHeapObjectId";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetSamplingProfileParams {}
impl<'de> serde::Deserialize<'de> for GetSamplingProfileParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetSamplingProfileParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetSamplingProfileParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetSamplingProfile;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetSamplingProfileResponse {
#[serde(rename = "profile")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub profile: crate::heap_profiler::types::SamplingHeapProfile,
}
impl<'de> serde::Deserialize<'de> for GetSamplingProfileResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetSamplingProfileResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "profile")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub profile: crate::heap_profiler::types::SamplingHeapProfile,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetSamplingProfileResponse {
profile: fields.profile,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetSamplingProfile {
type Params = GetSamplingProfileParams;
type Response = GetSamplingProfileResponse;
const METHOD: &'static str = "HeapProfiler.getSamplingProfile";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StartSamplingParams {
#[serde(rename = "samplingInterval")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub sampling_interval: Option<ydp_core::FiniteF64>,
#[serde(rename = "stackDepth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub stack_depth: Option<ydp_core::FiniteF64>,
#[serde(rename = "includeObjectsCollectedByMajorGC")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_objects_collected_by_major_gc: Option<bool>,
#[serde(rename = "includeObjectsCollectedByMinorGC")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_objects_collected_by_minor_gc: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for StartSamplingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartSamplingParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "samplingInterval")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub sampling_interval: Option<ydp_core::FiniteF64>,
#[serde(rename = "stackDepth")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub stack_depth: Option<ydp_core::FiniteF64>,
#[serde(rename = "includeObjectsCollectedByMajorGC")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_objects_collected_by_major_gc: Option<bool>,
#[serde(rename = "includeObjectsCollectedByMinorGC")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub include_objects_collected_by_minor_gc: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StartSamplingParams {
sampling_interval: fields.sampling_interval,
stack_depth: fields.stack_depth,
include_objects_collected_by_major_gc: fields
.include_objects_collected_by_major_gc,
include_objects_collected_by_minor_gc: fields
.include_objects_collected_by_minor_gc,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StartSampling;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StartSamplingResponse {}
impl<'de> serde::Deserialize<'de> for StartSamplingResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartSamplingResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StartSamplingResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StartSampling {
type Params = StartSamplingParams;
type Response = StartSamplingResponse;
const METHOD: &'static str = "HeapProfiler.startSampling";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StartTrackingHeapObjectsParams {
#[serde(rename = "trackAllocations")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub track_allocations: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for StartTrackingHeapObjectsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartTrackingHeapObjectsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "trackAllocations")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub track_allocations: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StartTrackingHeapObjectsParams {
track_allocations: fields.track_allocations,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StartTrackingHeapObjects;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StartTrackingHeapObjectsResponse {}
impl<'de> serde::Deserialize<'de> for StartTrackingHeapObjectsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StartTrackingHeapObjectsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StartTrackingHeapObjectsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StartTrackingHeapObjects {
type Params = StartTrackingHeapObjectsParams;
type Response = StartTrackingHeapObjectsResponse;
const METHOD: &'static str = "HeapProfiler.startTrackingHeapObjects";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StopSamplingParams {}
impl<'de> serde::Deserialize<'de> for StopSamplingParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopSamplingParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StopSamplingParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StopSampling;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StopSamplingResponse {
#[serde(rename = "profile")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub profile: crate::heap_profiler::types::SamplingHeapProfile,
}
impl<'de> serde::Deserialize<'de> for StopSamplingResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopSamplingResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "profile")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub profile: crate::heap_profiler::types::SamplingHeapProfile,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StopSamplingResponse {
profile: fields.profile,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StopSampling {
type Params = StopSamplingParams;
type Response = StopSamplingResponse;
const METHOD: &'static str = "HeapProfiler.stopSampling";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct StopTrackingHeapObjectsParams {
#[serde(rename = "reportProgress")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub report_progress: Option<bool>,
#[serde(rename = "treatGlobalObjectsAsRoots")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub treat_global_objects_as_roots: Option<bool>,
#[serde(rename = "captureNumericValue")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub capture_numeric_value: Option<bool>,
#[serde(rename = "exposeInternals")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub expose_internals: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for StopTrackingHeapObjectsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopTrackingHeapObjectsParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "reportProgress")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub report_progress: Option<bool>,
#[serde(rename = "treatGlobalObjectsAsRoots")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub treat_global_objects_as_roots: Option<bool>,
#[serde(rename = "captureNumericValue")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub capture_numeric_value: Option<bool>,
#[serde(rename = "exposeInternals")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub expose_internals: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StopTrackingHeapObjectsParams {
report_progress: fields.report_progress,
treat_global_objects_as_roots: fields.treat_global_objects_as_roots,
capture_numeric_value: fields.capture_numeric_value,
expose_internals: fields.expose_internals,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct StopTrackingHeapObjects;
#[derive(Debug, Clone, serde::Serialize)]
pub struct StopTrackingHeapObjectsResponse {}
impl<'de> serde::Deserialize<'de> for StopTrackingHeapObjectsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = StopTrackingHeapObjectsResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(StopTrackingHeapObjectsResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for StopTrackingHeapObjects {
type Params = StopTrackingHeapObjectsParams;
type Response = StopTrackingHeapObjectsResponse;
const METHOD: &'static str = "HeapProfiler.stopTrackingHeapObjects";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct TakeHeapSnapshotParams {
#[serde(rename = "reportProgress")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub report_progress: Option<bool>,
#[serde(rename = "treatGlobalObjectsAsRoots")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub treat_global_objects_as_roots: Option<bool>,
#[serde(rename = "captureNumericValue")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub capture_numeric_value: Option<bool>,
#[serde(rename = "exposeInternals")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub expose_internals: Option<bool>,
}
impl<'de> serde::Deserialize<'de> for TakeHeapSnapshotParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TakeHeapSnapshotParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "reportProgress")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub report_progress: Option<bool>,
#[serde(rename = "treatGlobalObjectsAsRoots")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub treat_global_objects_as_roots: Option<bool>,
#[serde(rename = "captureNumericValue")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub capture_numeric_value: Option<bool>,
#[serde(rename = "exposeInternals")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub expose_internals: Option<bool>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(TakeHeapSnapshotParams {
report_progress: fields.report_progress,
treat_global_objects_as_roots: fields.treat_global_objects_as_roots,
capture_numeric_value: fields.capture_numeric_value,
expose_internals: fields.expose_internals,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct TakeHeapSnapshot;
#[derive(Debug, Clone, serde::Serialize)]
pub struct TakeHeapSnapshotResponse {}
impl<'de> serde::Deserialize<'de> for TakeHeapSnapshotResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = TakeHeapSnapshotResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(TakeHeapSnapshotResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for TakeHeapSnapshot {
type Params = TakeHeapSnapshotParams;
type Response = TakeHeapSnapshotResponse;
const METHOD: &'static str = "HeapProfiler.takeHeapSnapshot";
}