#[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 = "Performance.disable";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum EnableParamsTimeDomain {
TimeTicks,
ThreadTicks,
Unknown(String),
}
impl EnableParamsTimeDomain {
pub fn as_str(&self) -> &str {
match self {
Self::TimeTicks => "timeTicks",
Self::ThreadTicks => "threadTicks",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for EnableParamsTimeDomain {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for EnableParamsTimeDomain {
fn from(value: String) -> Self {
match value.as_str() {
"timeTicks" => EnableParamsTimeDomain::TimeTicks,
"threadTicks" => EnableParamsTimeDomain::ThreadTicks,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for EnableParamsTimeDomain {
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 EnableParamsTimeDomain {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableParamsTimeDomain;
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 {
"timeTicks" => EnableParamsTimeDomain::TimeTicks,
"threadTicks" => EnableParamsTimeDomain::ThreadTicks,
_ => EnableParamsTimeDomain::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(EnableParamsTimeDomain::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct EnableParams {
#[serde(rename = "timeDomain")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub time_domain: Option<EnableParamsTimeDomain>,
}
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 {
#[serde(rename = "timeDomain")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub time_domain: Option<EnableParamsTimeDomain>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableParams {
time_domain: fields.time_domain,
})
}
}
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 = "Performance.enable";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct GetMetricsParams {}
impl<'de> serde::Deserialize<'de> for GetMetricsParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetMetricsParams;
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(GetMetricsParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct GetMetrics;
#[derive(Debug, Clone, serde::Serialize)]
pub struct GetMetricsResponse {
#[serde(rename = "metrics")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub metrics: Vec<crate::performance::types::Metric>,
}
impl<'de> serde::Deserialize<'de> for GetMetricsResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = GetMetricsResponse;
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 = "metrics")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub metrics: Vec<crate::performance::types::Metric>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(GetMetricsResponse {
metrics: fields.metrics,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for GetMetrics {
type Params = GetMetricsParams;
type Response = GetMetricsResponse;
const METHOD: &'static str = "Performance.getMetrics";
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SetTimeDomainParamsTimeDomain {
TimeTicks,
ThreadTicks,
Unknown(String),
}
impl SetTimeDomainParamsTimeDomain {
pub fn as_str(&self) -> &str {
match self {
Self::TimeTicks => "timeTicks",
Self::ThreadTicks => "threadTicks",
Self::Unknown(value) => value,
}
}
}
impl AsRef<str> for SetTimeDomainParamsTimeDomain {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl From<String> for SetTimeDomainParamsTimeDomain {
fn from(value: String) -> Self {
match value.as_str() {
"timeTicks" => SetTimeDomainParamsTimeDomain::TimeTicks,
"threadTicks" => SetTimeDomainParamsTimeDomain::ThreadTicks,
_ => Self::Unknown(value),
}
}
}
impl serde::Serialize for SetTimeDomainParamsTimeDomain {
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 SetTimeDomainParamsTimeDomain {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTimeDomainParamsTimeDomain;
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 {
"timeTicks" => SetTimeDomainParamsTimeDomain::TimeTicks,
"threadTicks" => SetTimeDomainParamsTimeDomain::ThreadTicks,
_ => SetTimeDomainParamsTimeDomain::Unknown(v.to_owned()),
})
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
Ok(SetTimeDomainParamsTimeDomain::from(v))
}
}
d.deserialize_str(Visitor)
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTimeDomainParams {
#[serde(rename = "timeDomain")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub time_domain: SetTimeDomainParamsTimeDomain,
}
impl<'de> serde::Deserialize<'de> for SetTimeDomainParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTimeDomainParams;
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 = "timeDomain")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub time_domain: SetTimeDomainParamsTimeDomain,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetTimeDomainParams {
time_domain: fields.time_domain,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetTimeDomain;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetTimeDomainResponse {}
impl<'de> serde::Deserialize<'de> for SetTimeDomainResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetTimeDomainResponse;
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(SetTimeDomainResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetTimeDomain {
type Params = SetTimeDomainParams;
type Response = SetTimeDomainResponse;
const METHOD: &'static str = "Performance.setTimeDomain";
}