#[derive(Debug, Clone, serde::Serialize)]
pub struct Player {
#[serde(rename = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "domNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub dom_node_id: Option<crate::dom::types::BackendNodeId>,
}
impl<'de> serde::Deserialize<'de> for Player {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = Player;
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 = "playerId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub player_id: crate::media::types::PlayerId,
#[serde(rename = "domNodeId")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub dom_node_id: Option<crate::dom::types::BackendNodeId>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(Player {
player_id: fields.player_id,
dom_node_id: fields.dom_node_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerError {
#[serde(rename = "errorType")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_type: String,
#[serde(rename = "code")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub code: i64,
#[serde(rename = "stack")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub stack: Vec<crate::media::types::PlayerErrorSourceLocation>,
#[serde(rename = "cause")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cause: Vec<crate::media::types::PlayerError>,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: std::collections::BTreeMap<String, serde_json::Value>,
}
impl<'de> serde::Deserialize<'de> for PlayerError {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerError;
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 = "errorType")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub error_type: String,
#[serde(rename = "code")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub code: i64,
#[serde(rename = "stack")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub stack: Vec<crate::media::types::PlayerErrorSourceLocation>,
#[serde(rename = "cause")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub cause: Vec<crate::media::types::PlayerError>,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: std::collections::BTreeMap<String, serde_json::Value>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerError {
error_type: fields.error_type,
code: fields.code,
stack: fields.stack,
cause: fields.cause,
data: fields.data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerErrorSourceLocation {
#[serde(rename = "file")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub file: String,
#[serde(rename = "line")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub line: i64,
}
impl<'de> serde::Deserialize<'de> for PlayerErrorSourceLocation {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerErrorSourceLocation;
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 = "file")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub file: String,
#[serde(rename = "line")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub line: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerErrorSourceLocation {
file: fields.file,
line: fields.line,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerEvent {
#[serde(rename = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::media::types::Timestamp,
#[serde(rename = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: String,
}
impl<'de> serde::Deserialize<'de> for PlayerEvent {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerEvent;
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 = "timestamp")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub timestamp: crate::media::types::Timestamp,
#[serde(rename = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerEvent {
timestamp: fields.timestamp,
value: fields.value,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(transparent)]
pub struct PlayerId(String);
impl PlayerId {
pub fn new(value: String) -> Self {
Self(value)
}
pub fn into_inner(self) -> String {
self.0
}
pub fn as_str(&self) -> &str {
&self.0
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum PlayerMessageLevel {
Error,
Warning,
Info,
Debug,
Unknown(String),
}
impl PlayerMessageLevel {
pub fn as_str(&self) -> &str {
match self {
Self::Error => "error",
Self::Warning => "warning",
Self::Info => "info",
Self::Debug => "debug",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for PlayerMessageLevel {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for PlayerMessageLevel {
fn from(value: String) -> Self {
match value.as_str() {
"error" => PlayerMessageLevel::Error,
"warning" => PlayerMessageLevel::Warning,
"info" => PlayerMessageLevel::Info,
"debug" => PlayerMessageLevel::Debug,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for PlayerMessageLevel {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for PlayerMessageLevel {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerMessageLevel;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议字符串枚举")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
Ok(match v {
"error" => PlayerMessageLevel::Error,
"warning" => PlayerMessageLevel::Warning,
"info" => PlayerMessageLevel::Info,
"debug" => PlayerMessageLevel::Debug,
_ => PlayerMessageLevel::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(PlayerMessageLevel::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerMessage {
#[serde(rename = "level")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub level: PlayerMessageLevel,
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: String,
}
impl<'de> serde::Deserialize<'de> for PlayerMessage {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerMessage;
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 = "level")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub level: PlayerMessageLevel,
#[serde(rename = "message")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub message: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerMessage {
level: fields.level,
message: fields.message,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct PlayerProperty {
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: String,
}
impl<'de> serde::Deserialize<'de> for PlayerProperty {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PlayerProperty;
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 = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "value")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub value: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(PlayerProperty {
name: fields.name,
value: fields.value,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(transparent)]
pub struct Timestamp(ydp_core::FiniteF64);
impl Timestamp {
pub fn new(value: ydp_core::FiniteF64) -> Self {
Self(value)
}
pub fn into_inner(self) -> ydp_core::FiniteF64 {
self.0
}
}