use std::fmt;
use jsonx_lib::Number;
use crate::{
error::Error,
handles::Peer,
message::{is_token, read_member},
raw::{Json, Raw},
router::Params,
};
impl Params<'_> {
#[must_use]
pub fn progress_token(&self) -> Option<Raw<'_>> {
let parser = self.parser();
let meta = read_member(self.text()?, "_meta", &parser)?;
token(read_member(meta, "progressToken", &parser)?)
}
#[must_use]
pub fn work_done_token(&self) -> Option<Raw<'_>> {
token(read_member(self.text()?, "workDoneToken", &self.parser())?)
}
}
fn token(raw: &str) -> Option<Raw<'_>> {
is_token(raw).then(|| Raw::trusted(raw))
}
fn push_number(out: &mut String, name: &str, n: f64) -> Result<(), Error> {
const EXACT: f64 = 9_007_199_254_740_992.0;
let number = Number::from_f64(n)
.ok_or_else(|| Error::Serialize(format!("`{name}` must be a finite number, not {n}")))?;
out.push(',');
jsonx_lib::write_string(out, name);
out.push(':');
if n.fract() == 0.0 && n.abs() < EXACT {
crate::text::push_i64(out, n as i64);
} else {
out.push_str(number.as_str());
}
Ok(())
}
fn push_text(out: &mut String, name: &str, text: Option<&str>) {
if let Some(text) = text {
out.push(',');
jsonx_lib::write_string(out, name);
out.push(':');
jsonx_lib::write_string(out, text);
}
}
#[derive(Clone)]
pub struct Progress {
peer: Peer,
token: Raw<'static>,
}
impl Progress {
#[must_use]
pub fn new(peer: Peer, token: Raw<'_>) -> Self {
Self {
peer,
token: token.into_owned(),
}
}
#[must_use]
pub fn from_params(params: &Params<'_>, peer: Peer) -> Option<Self> {
params.progress_token().map(|token| Self::new(peer, token))
}
#[must_use]
pub fn token(&self) -> &Raw<'static> {
&self.token
}
pub fn report(
&self,
progress: f64,
total: Option<f64>,
message: Option<&str>,
) -> Result<(), Error> {
let mut params = String::from("{\"progressToken\":");
params.push_str(self.token.as_str());
push_number(&mut params, "progress", progress)?;
if let Some(total) = total {
push_number(&mut params, "total", total)?;
}
push_text(&mut params, "message", message);
params.push('}');
self.peer.notify(
"notifications/progress",
Json::Raw(Raw::trusted_owned(params)),
)
}
}
impl fmt::Debug for Progress {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Progress")
.field("token", &self.token)
.finish_non_exhaustive()
}
}
#[derive(Clone)]
pub struct WorkDone {
peer: Peer,
token: Raw<'static>,
}
impl WorkDone {
#[must_use]
pub fn new(peer: Peer, token: Raw<'_>) -> Self {
Self {
peer,
token: token.into_owned(),
}
}
#[must_use]
pub fn from_params(params: &Params<'_>, peer: Peer) -> Option<Self> {
params.work_done_token().map(|token| Self::new(peer, token))
}
#[must_use]
pub fn token(&self) -> &Raw<'static> {
&self.token
}
pub fn begin(
&self,
title: &str,
cancellable: bool,
message: Option<&str>,
percentage: Option<u32>,
) -> Result<(), Error> {
let mut value = String::from("{\"kind\":\"begin\"");
push_text(&mut value, "title", Some(title));
value.push_str(if cancellable {
",\"cancellable\":true"
} else {
",\"cancellable\":false"
});
push_text(&mut value, "message", message);
push_percentage(&mut value, percentage);
self.send(value)
}
pub fn report(&self, message: Option<&str>, percentage: Option<u32>) -> Result<(), Error> {
let mut value = String::from("{\"kind\":\"report\"");
push_text(&mut value, "message", message);
push_percentage(&mut value, percentage);
self.send(value)
}
pub fn end(&self, message: Option<&str>) -> Result<(), Error> {
let mut value = String::from("{\"kind\":\"end\"");
push_text(&mut value, "message", message);
self.send(value)
}
fn send(&self, mut value: String) -> Result<(), Error> {
value.push('}');
let mut params = String::from("{\"token\":");
params.push_str(self.token.as_str());
params.push_str(",\"value\":");
params.push_str(&value);
params.push('}');
self.peer
.notify("$/progress", Json::Raw(Raw::trusted_owned(params)))
}
}
fn push_percentage(out: &mut String, percentage: Option<u32>) {
if let Some(percentage) = percentage {
out.push_str(",\"percentage\":");
crate::text::push_u64(out, u64::from(percentage.min(100)));
}
}
impl fmt::Debug for WorkDone {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("WorkDone")
.field("token", &self.token)
.finish_non_exhaustive()
}
}