#[derive(Debug, Clone, serde::Serialize)]
pub struct CloseParams {
#[serde(rename = "handle")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub handle: crate::io::types::StreamHandle,
}
impl<'de> serde::Deserialize<'de> for CloseParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CloseParams;
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 = "handle")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub handle: crate::io::types::StreamHandle,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(CloseParams {
handle: fields.handle,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Close;
#[derive(Debug, Clone, serde::Serialize)]
pub struct CloseResponse {}
impl<'de> serde::Deserialize<'de> for CloseResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = CloseResponse;
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(CloseResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Close {
type Params = CloseParams;
type Response = CloseResponse;
const METHOD: &'static str = "IO.close";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReadParams {
#[serde(rename = "handle")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub handle: crate::io::types::StreamHandle,
#[serde(rename = "offset")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub offset: Option<i64>,
#[serde(rename = "size")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub size: Option<i64>,
}
impl<'de> serde::Deserialize<'de> for ReadParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReadParams;
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 = "handle")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub handle: crate::io::types::StreamHandle,
#[serde(rename = "offset")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub offset: Option<i64>,
#[serde(rename = "size")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub size: Option<i64>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReadParams {
handle: fields.handle,
offset: fields.offset,
size: fields.size,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Read;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ReadResponse {
#[serde(rename = "base64Encoded")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub base64_encoded: Option<bool>,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "eof")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub eof: bool,
}
impl<'de> serde::Deserialize<'de> for ReadResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ReadResponse;
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 = "base64Encoded")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub base64_encoded: Option<bool>,
#[serde(rename = "data")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub data: String,
#[serde(rename = "eof")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub eof: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ReadResponse {
base64_encoded: fields.base64_encoded,
data: fields.data,
eof: fields.eof,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Read {
type Params = ReadParams;
type Response = ReadResponse;
const METHOD: &'static str = "IO.read";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResolveBlobParams {
#[serde(rename = "objectId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub object_id: crate::runtime::types::RemoteObjectId,
}
impl<'de> serde::Deserialize<'de> for ResolveBlobParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResolveBlobParams;
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(ResolveBlobParams {
object_id: fields.object_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ResolveBlob;
#[derive(Debug, Clone, serde::Serialize)]
pub struct ResolveBlobResponse {
#[serde(rename = "uuid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub uuid: String,
}
impl<'de> serde::Deserialize<'de> for ResolveBlobResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = ResolveBlobResponse;
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 = "uuid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub uuid: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(ResolveBlobResponse { uuid: fields.uuid })
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for ResolveBlob {
type Params = ResolveBlobParams;
type Response = ResolveBlobResponse;
const METHOD: &'static str = "IO.resolveBlob";
}