use serde_json::Value;
use super::{Session, SessionInner};
use crate::client::lock;
use crate::fold::{DeliveryGap, PendingApproval, SessionFold, Turn};
use crate::msp::{HistoryMode, Notification, ViewGapParams};
impl Session {
pub fn fold(&self) -> SessionFoldView<'_> {
SessionFoldView { inner: &self.inner }
}
pub(crate) fn mark_fold_reopened(&self) {
self.inner.mark_fold_reopened();
}
}
pub struct SessionFoldView<'a> {
inner: &'a SessionInner,
}
impl SessionFoldView<'_> {
fn read<R>(&self, read: impl FnOnce(&SessionFold) -> R) -> R {
read(&lock(&self.inner.fold))
}
pub fn item(&self, id: &str) -> Option<Value> {
self.read(|fold| fold.items().get(id).cloned())
}
pub fn item_count(&self) -> usize {
self.read(|fold| fold.items().len())
}
pub fn item_ids(&self) -> Vec<String> {
self.read(|fold| fold.items().ids().to_vec())
}
pub fn accumulated(&self, id: &str, field: &str) -> Option<String> {
self.read(|fold| fold.items().accumulated(id, field).map(str::to_owned))
}
pub fn session_state(&self, family: &str) -> Option<Value> {
self.read(|fold| fold.session_state().get(family).cloned())
}
pub fn active_turn_id(&self) -> Option<String> {
self.read(|fold| fold.active_turn_id().map(str::to_owned))
}
pub fn turn(&self, id: &str) -> Option<Turn> {
self.read(|fold| fold.turn(id).cloned())
}
pub fn turn_ids(&self) -> Vec<String> {
self.read(|fold| fold.turn_ids().to_vec())
}
pub fn pending_gap(&self) -> Option<DeliveryGap> {
self.read(|fold| fold.pending_gap().cloned())
}
pub fn is_current(&self) -> bool {
self.read(SessionFold::is_current)
}
pub fn is_stopped(&self) -> bool {
self.read(SessionFold::is_stopped)
}
pub fn pending_approval(&self, id: &str) -> Option<Value> {
self.read(|fold| fold.pending_approval(id).cloned())
}
pub fn resolved_approval(&self, id: &str) -> Option<Value> {
self.read(|fold| fold.resolved_approval(id).cloned())
}
pub fn pending_approvals(&self) -> Vec<PendingApproval> {
self.read(|fold| fold.pending_approvals().into_iter().cloned().collect())
}
pub fn resolved_approvals(&self) -> Vec<Value> {
self.read(|fold| fold.resolved_approvals().into_iter().cloned().collect())
}
pub fn pending_user_input(&self, id: &str) -> Option<Value> {
self.read(|fold| fold.pending_user_input(id).cloned())
}
pub fn settled_user_input(&self, id: &str) -> Option<Value> {
self.read(|fold| fold.settled_user_input(id).cloned())
}
pub fn pending_user_inputs(&self) -> Vec<Value> {
self.read(|fold| fold.pending_user_inputs().into_iter().cloned().collect())
}
pub fn settled_user_inputs(&self) -> Vec<Value> {
self.read(|fold| fold.settled_user_inputs().into_iter().cloned().collect())
}
}
impl SessionInner {
pub(super) fn fold_event(&self, notification: &Notification) {
if notification.method == "userInput/request" {
let mut twin = notification.clone();
twin.method = "userInput/requested".to_owned();
lock(&self.fold).apply(&twin);
return;
}
lock(&self.fold).apply(notification);
}
pub(super) fn mirror_gap(&self, gap: Option<&ViewGapParams>) {
lock(&self.fold).track_gap(gap);
}
pub(crate) fn mark_fold_lost(&self) {
lock(&self.fold).mark_lost();
}
pub(crate) fn mark_fold_reopened(&self) {
lock(&self.fold).mark_reopened();
}
pub(super) fn stop_fold_on_cut_fill(&self) {
lock(&self.fold).stop_if_gap_pending();
}
}
pub(super) fn seeded_fold(session_id: &str, history: &[Value]) -> SessionFold {
let mut fold = SessionFold::new(session_id);
for item in history.iter().filter_map(Value::as_object) {
fold.seed_history_item(item);
}
fold
}
pub(crate) const SNAPSHOT_SCHEMA_VERSION: u64 = 1;
pub(crate) fn drop_unreadable_snapshot(result: &mut Value) -> Option<u64> {
let version = result
.pointer("/history/snapshot/schemaVersion")
.and_then(Value::as_u64)
.filter(|version| *version > SNAPSHOT_SCHEMA_VERSION)?;
*result.pointer_mut("/history/snapshot")? = Value::Null;
Some(version)
}
pub(crate) fn resume_history_items<'a>(result: &'a Value, mode: &HistoryMode) -> &'a [Value] {
if matches!(mode, HistoryMode::Unknown(_)) {
return &[];
}
["/history/items", "/history/snapshot/state/items"]
.iter()
.find_map(|pointer| result.pointer(pointer).and_then(Value::as_array))
.map_or(&[], Vec::as_slice)
}