#[derive(Debug, Clone, serde::Serialize)]
pub struct CompositingReasonsParams {
#[serde(rename = "layerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub layer_id: crate::layer_tree::types::LayerId,
}
impl<'de> serde::Deserialize<'de> for CompositingReasonsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CompositingReasonsParams;
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 = "layerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub layer_id: crate::layer_tree::types::LayerId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CompositingReasonsParams {
layer_id: fields.layer_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct CompositingReasons;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CompositingReasonsResponse {
#[serde(rename = "compositingReasons")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub compositing_reasons: Vec<String>,
#[serde(rename = "compositingReasonIds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub compositing_reason_ids: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for CompositingReasonsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CompositingReasonsResponse;
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 = "compositingReasons")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub compositing_reasons: Vec<String>,
#[serde(rename = "compositingReasonIds")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub compositing_reason_ids: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CompositingReasonsResponse {
compositing_reasons: fields.compositing_reasons,
compositing_reason_ids: fields.compositing_reason_ids,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for CompositingReasons {
type Params = CompositingReasonsParams;
type Response = CompositingReasonsResponse;
const METHOD: &'static str = "LayerTree.compositingReasons";
}
#[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 = "LayerTree.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 = "LayerTree.enable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct LoadSnapshotParams {
#[serde(rename = "tiles")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub tiles: Vec<crate::layer_tree::types::PictureTile>,
}
impl<'de> serde::Deserialize<'de> for LoadSnapshotParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LoadSnapshotParams;
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 = "tiles")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub tiles: Vec<crate::layer_tree::types::PictureTile>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LoadSnapshotParams {
tiles: fields.tiles,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct LoadSnapshot;
#[derive(Debug, Clone, serde::Serialize)]
pub struct LoadSnapshotResponse {
#[serde(rename = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
}
impl<'de> serde::Deserialize<'de> for LoadSnapshotResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = LoadSnapshotResponse;
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 = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(LoadSnapshotResponse {
snapshot_id: fields.snapshot_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for LoadSnapshot {
type Params = LoadSnapshotParams;
type Response = LoadSnapshotResponse;
const METHOD: &'static str = "LayerTree.loadSnapshot";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct MakeSnapshotParams {
#[serde(rename = "layerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub layer_id: crate::layer_tree::types::LayerId,
}
impl<'de> serde::Deserialize<'de> for MakeSnapshotParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = MakeSnapshotParams;
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 = "layerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub layer_id: crate::layer_tree::types::LayerId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(MakeSnapshotParams {
layer_id: fields.layer_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct MakeSnapshot;
#[derive(Debug, Clone, serde::Serialize)]
pub struct MakeSnapshotResponse {
#[serde(rename = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
}
impl<'de> serde::Deserialize<'de> for MakeSnapshotResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = MakeSnapshotResponse;
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 = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(MakeSnapshotResponse {
snapshot_id: fields.snapshot_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for MakeSnapshot {
type Params = MakeSnapshotParams;
type Response = MakeSnapshotResponse;
const METHOD: &'static str = "LayerTree.makeSnapshot";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ProfileSnapshotParams {
#[serde(rename = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
#[serde(rename = "minRepeatCount")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub min_repeat_count: Option<i64>,
#[serde(rename = "minDuration")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub min_duration: Option<ydp_core::FiniteF64>,
#[serde(rename = "clipRect")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub clip_rect: Option<crate::dom::types::Rect>,
}
impl<'de> serde::Deserialize<'de> for ProfileSnapshotParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ProfileSnapshotParams;
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 = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
#[serde(rename = "minRepeatCount")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub min_repeat_count: Option<i64>,
#[serde(rename = "minDuration")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub min_duration: Option<ydp_core::FiniteF64>,
#[serde(rename = "clipRect")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub clip_rect: Option<crate::dom::types::Rect>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ProfileSnapshotParams {
snapshot_id: fields.snapshot_id,
min_repeat_count: fields.min_repeat_count,
min_duration: fields.min_duration,
clip_rect: fields.clip_rect,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ProfileSnapshot;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ProfileSnapshotResponse {
#[serde(rename = "timings")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timings: Vec<crate::layer_tree::types::PaintProfile>,
}
impl<'de> serde::Deserialize<'de> for ProfileSnapshotResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ProfileSnapshotResponse;
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 = "timings")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timings: Vec<crate::layer_tree::types::PaintProfile>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ProfileSnapshotResponse {
timings: fields.timings,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ProfileSnapshot {
type Params = ProfileSnapshotParams;
type Response = ProfileSnapshotResponse;
const METHOD: &'static str = "LayerTree.profileSnapshot";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReleaseSnapshotParams {
#[serde(rename = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
}
impl<'de> serde::Deserialize<'de> for ReleaseSnapshotParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReleaseSnapshotParams;
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 = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReleaseSnapshotParams {
snapshot_id: fields.snapshot_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ReleaseSnapshot;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReleaseSnapshotResponse {}
impl<'de> serde::Deserialize<'de> for ReleaseSnapshotResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReleaseSnapshotResponse;
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(ReleaseSnapshotResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ReleaseSnapshot {
type Params = ReleaseSnapshotParams;
type Response = ReleaseSnapshotResponse;
const METHOD: &'static str = "LayerTree.releaseSnapshot";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReplaySnapshotParams {
#[serde(rename = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
#[serde(rename = "fromStep")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub from_step: Option<i64>,
#[serde(rename = "toStep")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub to_step: Option<i64>,
#[serde(rename = "scale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scale: Option<ydp_core::FiniteF64>,
}
impl<'de> serde::Deserialize<'de> for ReplaySnapshotParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReplaySnapshotParams;
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 = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
#[serde(rename = "fromStep")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub from_step: Option<i64>,
#[serde(rename = "toStep")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub to_step: Option<i64>,
#[serde(rename = "scale")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub scale: Option<ydp_core::FiniteF64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReplaySnapshotParams {
snapshot_id: fields.snapshot_id,
from_step: fields.from_step,
to_step: fields.to_step,
scale: fields.scale,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ReplaySnapshot;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReplaySnapshotResponse {
#[serde(rename = "dataURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data_url: String,
}
impl<'de> serde::Deserialize<'de> for ReplaySnapshotResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReplaySnapshotResponse;
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 = "dataURL")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data_url: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReplaySnapshotResponse {
data_url: fields.data_url,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ReplaySnapshot {
type Params = ReplaySnapshotParams;
type Response = ReplaySnapshotResponse;
const METHOD: &'static str = "LayerTree.replaySnapshot";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SnapshotCommandLogParams {
#[serde(rename = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
}
impl<'de> serde::Deserialize<'de> for SnapshotCommandLogParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SnapshotCommandLogParams;
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 = "snapshotId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub snapshot_id: crate::layer_tree::types::SnapshotId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SnapshotCommandLogParams {
snapshot_id: fields.snapshot_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SnapshotCommandLog;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SnapshotCommandLogResponse {
#[serde(rename = "commandLog")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub command_log: Vec<std::collections::BTreeMap<String, serde_json::Value>>,
}
impl<'de> serde::Deserialize<'de> for SnapshotCommandLogResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SnapshotCommandLogResponse;
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 = "commandLog")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub command_log: Vec<std::collections::BTreeMap<String, serde_json::Value>>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SnapshotCommandLogResponse {
command_log: fields.command_log,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SnapshotCommandLog {
type Params = SnapshotCommandLogParams;
type Response = SnapshotCommandLogResponse;
const METHOD: &'static str = "LayerTree.snapshotCommandLog";
}