#[derive(Debug, Clone, serde::Serialize)]
pub struct AudioListenerCreatedParams {
#[serde(rename = "listener")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub listener: crate::web_audio::types::AudioListener,
}
impl<'de> serde::Deserialize<'de> for AudioListenerCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AudioListenerCreatedParams;
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 = "listener")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub listener: crate::web_audio::types::AudioListener,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AudioListenerCreatedParams {
listener: fields.listener,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AudioListenerCreated;
impl ydp_core::Event for AudioListenerCreated {
type Params = AudioListenerCreatedParams;
const METHOD: &'static str = "WebAudio.audioListenerCreated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AudioListenerWillBeDestroyedParams {
#[serde(rename = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "listenerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub listener_id: crate::web_audio::types::GraphObjectId,
}
impl<'de> serde::Deserialize<'de> for AudioListenerWillBeDestroyedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AudioListenerWillBeDestroyedParams;
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 = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "listenerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub listener_id: crate::web_audio::types::GraphObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AudioListenerWillBeDestroyedParams {
context_id: fields.context_id,
listener_id: fields.listener_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AudioListenerWillBeDestroyed;
impl ydp_core::Event for AudioListenerWillBeDestroyed {
type Params = AudioListenerWillBeDestroyedParams;
const METHOD: &'static str = "WebAudio.audioListenerWillBeDestroyed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AudioNodeCreatedParams {
#[serde(rename = "node")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node: crate::web_audio::types::AudioNode,
}
impl<'de> serde::Deserialize<'de> for AudioNodeCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AudioNodeCreatedParams;
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 = "node")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node: crate::web_audio::types::AudioNode,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AudioNodeCreatedParams { node: fields.node })
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AudioNodeCreated;
impl ydp_core::Event for AudioNodeCreated {
type Params = AudioNodeCreatedParams;
const METHOD: &'static str = "WebAudio.audioNodeCreated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AudioNodeWillBeDestroyedParams {
#[serde(rename = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::web_audio::types::GraphObjectId,
}
impl<'de> serde::Deserialize<'de> for AudioNodeWillBeDestroyedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AudioNodeWillBeDestroyedParams;
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 = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::web_audio::types::GraphObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AudioNodeWillBeDestroyedParams {
context_id: fields.context_id,
node_id: fields.node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AudioNodeWillBeDestroyed;
impl ydp_core::Event for AudioNodeWillBeDestroyed {
type Params = AudioNodeWillBeDestroyedParams;
const METHOD: &'static str = "WebAudio.audioNodeWillBeDestroyed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AudioParamCreatedParams {
#[serde(rename = "param")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub param: crate::web_audio::types::AudioParam,
}
impl<'de> serde::Deserialize<'de> for AudioParamCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AudioParamCreatedParams;
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 = "param")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub param: crate::web_audio::types::AudioParam,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AudioParamCreatedParams {
param: fields.param,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AudioParamCreated;
impl ydp_core::Event for AudioParamCreated {
type Params = AudioParamCreatedParams;
const METHOD: &'static str = "WebAudio.audioParamCreated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AudioParamWillBeDestroyedParams {
#[serde(rename = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "paramId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub param_id: crate::web_audio::types::GraphObjectId,
}
impl<'de> serde::Deserialize<'de> for AudioParamWillBeDestroyedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AudioParamWillBeDestroyedParams;
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 = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "nodeId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub node_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "paramId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub param_id: crate::web_audio::types::GraphObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AudioParamWillBeDestroyedParams {
context_id: fields.context_id,
node_id: fields.node_id,
param_id: fields.param_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AudioParamWillBeDestroyed;
impl ydp_core::Event for AudioParamWillBeDestroyed {
type Params = AudioParamWillBeDestroyedParams;
const METHOD: &'static str = "WebAudio.audioParamWillBeDestroyed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ContextChangedParams {
#[serde(rename = "context")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context: crate::web_audio::types::BaseAudioContext,
}
impl<'de> serde::Deserialize<'de> for ContextChangedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ContextChangedParams;
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 = "context")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context: crate::web_audio::types::BaseAudioContext,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ContextChangedParams {
context: fields.context,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ContextChanged;
impl ydp_core::Event for ContextChanged {
type Params = ContextChangedParams;
const METHOD: &'static str = "WebAudio.contextChanged";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ContextCreatedParams {
#[serde(rename = "context")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context: crate::web_audio::types::BaseAudioContext,
}
impl<'de> serde::Deserialize<'de> for ContextCreatedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ContextCreatedParams;
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 = "context")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context: crate::web_audio::types::BaseAudioContext,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ContextCreatedParams {
context: fields.context,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ContextCreated;
impl ydp_core::Event for ContextCreated {
type Params = ContextCreatedParams;
const METHOD: &'static str = "WebAudio.contextCreated";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ContextWillBeDestroyedParams {
#[serde(rename = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
}
impl<'de> serde::Deserialize<'de> for ContextWillBeDestroyedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ContextWillBeDestroyedParams;
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 = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ContextWillBeDestroyedParams {
context_id: fields.context_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ContextWillBeDestroyed;
impl ydp_core::Event for ContextWillBeDestroyed {
type Params = ContextWillBeDestroyedParams;
const METHOD: &'static str = "WebAudio.contextWillBeDestroyed";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct NodeParamConnectedParams {
#[serde(rename = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "destinationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub destination_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceOutputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub source_output_index: Option<ydp_core::FiniteF64>,
}
impl<'de> serde::Deserialize<'de> for NodeParamConnectedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NodeParamConnectedParams;
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 = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "destinationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub destination_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceOutputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub source_output_index: Option<ydp_core::FiniteF64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NodeParamConnectedParams {
context_id: fields.context_id,
source_id: fields.source_id,
destination_id: fields.destination_id,
source_output_index: fields.source_output_index,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct NodeParamConnected;
impl ydp_core::Event for NodeParamConnected {
type Params = NodeParamConnectedParams;
const METHOD: &'static str = "WebAudio.nodeParamConnected";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct NodeParamDisconnectedParams {
#[serde(rename = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "destinationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub destination_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceOutputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub source_output_index: Option<ydp_core::FiniteF64>,
}
impl<'de> serde::Deserialize<'de> for NodeParamDisconnectedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NodeParamDisconnectedParams;
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 = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "destinationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub destination_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceOutputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub source_output_index: Option<ydp_core::FiniteF64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NodeParamDisconnectedParams {
context_id: fields.context_id,
source_id: fields.source_id,
destination_id: fields.destination_id,
source_output_index: fields.source_output_index,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct NodeParamDisconnected;
impl ydp_core::Event for NodeParamDisconnected {
type Params = NodeParamDisconnectedParams;
const METHOD: &'static str = "WebAudio.nodeParamDisconnected";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct NodesConnectedParams {
#[serde(rename = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "destinationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub destination_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceOutputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub source_output_index: Option<ydp_core::FiniteF64>,
#[serde(rename = "destinationInputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub destination_input_index: Option<ydp_core::FiniteF64>,
}
impl<'de> serde::Deserialize<'de> for NodesConnectedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NodesConnectedParams;
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 = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "destinationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub destination_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceOutputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub source_output_index: Option<ydp_core::FiniteF64>,
#[serde(rename = "destinationInputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub destination_input_index: Option<ydp_core::FiniteF64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NodesConnectedParams {
context_id: fields.context_id,
source_id: fields.source_id,
destination_id: fields.destination_id,
source_output_index: fields.source_output_index,
destination_input_index: fields.destination_input_index,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct NodesConnected;
impl ydp_core::Event for NodesConnected {
type Params = NodesConnectedParams;
const METHOD: &'static str = "WebAudio.nodesConnected";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct NodesDisconnectedParams {
#[serde(rename = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "destinationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub destination_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceOutputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub source_output_index: Option<ydp_core::FiniteF64>,
#[serde(rename = "destinationInputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub destination_input_index: Option<ydp_core::FiniteF64>,
}
impl<'de> serde::Deserialize<'de> for NodesDisconnectedParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = NodesDisconnectedParams;
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 = "contextId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub context_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub source_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "destinationId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub destination_id: crate::web_audio::types::GraphObjectId,
#[serde(rename = "sourceOutputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub source_output_index: Option<ydp_core::FiniteF64>,
#[serde(rename = "destinationInputIndex")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub destination_input_index: Option<ydp_core::FiniteF64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(NodesDisconnectedParams {
context_id: fields.context_id,
source_id: fields.source_id,
destination_id: fields.destination_id,
source_output_index: fields.source_output_index,
destination_input_index: fields.destination_input_index,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct NodesDisconnected;
impl ydp_core::Event for NodesDisconnected {
type Params = NodesDisconnectedParams;
const METHOD: &'static str = "WebAudio.nodesDisconnected";
}