use std::{
fmt,
sync::{Arc, Mutex, PoisonError},
};
use crate::{
convert::with_buffer,
error::Error,
handles::{Peer, Responder},
link::Scope,
message::{is_token, read_member},
raw::{Json, Raw},
router::{Context, 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 finite(name: &str, n: f64) -> Result<(), Error> {
if n.is_finite() {
Ok(())
} else {
Err(Error::Serialize(format!(
"`{name}` must be a finite number, not {n}"
)))
}
}
fn push_number(out: &mut String, name: &str, n: f64) {
const EXACT: f64 = 9_007_199_254_740_992.0;
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 {
jsonx_lib::write_value(out, &n);
}
}
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>,
scope: Scope,
last: Arc<Mutex<Option<f64>>>,
}
impl Progress {
#[must_use]
pub fn new(peer: Peer, token: Raw<'_>) -> Self {
Self::scoped(peer, token, Scope::Free)
}
fn scoped(peer: Peer, token: Raw<'_>, scope: Scope) -> Self {
Self {
peer,
token: token.into_owned(),
scope,
last: Arc::default(),
}
}
#[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> {
finite("progress", progress)?;
if let Some(total) = total {
finite("total", total)?;
}
let bound = !matches!(self.scope, Scope::Free);
let mut last = (!bound).then(|| self.last.lock().unwrap_or_else(PoisonError::into_inner));
if let Some(Some(last)) = last.as_deref() {
if progress <= *last {
return Err(Error::ProgressNotIncreasing {
last: *last,
next: progress,
});
}
}
let fill = |out: &mut String| {
out.push_str("{\"progressToken\":");
out.push_str(self.token.as_str());
push_number(out, "progress", progress);
if let Some(total) = total {
push_number(out, "total", total);
}
push_text(out, "message", message);
out.push('}');
};
with_buffer(fill, |params| {
self.peer.link().notify_in(
&self.scope,
bound.then_some(progress),
"notifications/progress",
Some(&Json::Raw(params)),
)
})?;
if let Some(last) = last.as_deref_mut() {
*last = Some(progress);
}
Ok(())
}
}
impl Context<'_> {
#[must_use]
pub fn progress(&self, params: &Params<'_>) -> Option<Progress> {
let scope = self.scope()?;
let token = params.progress_token()?;
Some(Progress::scoped(self.peer(), token, scope))
}
}
impl Responder {
#[must_use]
pub fn progress(&self, params: &Params<'_>) -> Option<Progress> {
let token = params.progress_token()?;
Some(Progress::scoped(self.peer(), token, self.scope()))
}
}
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> {
self.send(|value| {
value.push_str("{\"kind\":\"begin\"");
push_text(value, "title", Some(title));
value.push_str(if cancellable {
",\"cancellable\":true"
} else {
",\"cancellable\":false"
});
push_text(value, "message", message);
push_percentage(value, percentage);
})
}
pub fn report(&self, message: Option<&str>, percentage: Option<u32>) -> Result<(), Error> {
self.send(|value| {
value.push_str("{\"kind\":\"report\"");
push_text(value, "message", message);
push_percentage(value, percentage);
})
}
pub fn end(&self, message: Option<&str>) -> Result<(), Error> {
self.send(|value| {
value.push_str("{\"kind\":\"end\"");
push_text(value, "message", message);
})
}
fn send(&self, members: impl FnOnce(&mut String)) -> Result<(), Error> {
let fill = |out: &mut String| {
out.push_str("{\"token\":");
out.push_str(self.token.as_str());
out.push_str(",\"value\":");
members(out);
out.push_str("}}");
};
with_buffer(fill, |params| self.peer.notify("$/progress", 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()
}
}