use std::{
cell::RefCell,
rc::{Rc, Weak},
};
use super::{
Computed, Context, DropResource, Graph, GraphId, ToComputed,
graph::{ErasedNode, GraphInner, Node},
};
type ValueEvents = Vec<(u64, Rc<dyn Fn()>)>;
pub struct Value<T: Clone + PartialEq + 'static> {
inner: Rc<ValueInner<T>>,
}
struct ValueInner<T: Clone + PartialEq + 'static> {
node: Node,
value: RefCell<T>,
next_event: RefCell<u64>,
events: RefCell<ValueEvents>,
}
impl<T: Clone + PartialEq + 'static> Clone for Value<T> {
fn clone(&self) -> Self {
Value {
inner: self.inner.clone(),
}
}
}
impl<T: Clone + PartialEq + 'static> PartialEq for Value<T> {
fn eq(&self, other: &Self) -> bool {
self.inner.node.id == other.inner.node.id
}
}
impl<T: Clone + PartialEq + Default + 'static> Default for Value<T> {
fn default() -> Self {
Self::new(T::default())
}
}
impl<T: Clone + PartialEq + 'static> ErasedNode for ValueInner<T> {
fn refresh(&self) -> bool {
true
}
}
impl<T: Clone + PartialEq + 'static> Value<T> {
pub(crate) fn create(graph: Rc<GraphInner>, value: T) -> Self {
let inner = Rc::new(ValueInner {
node: Node::new(graph),
value: RefCell::new(value),
next_event: RefCell::new(1),
events: RefCell::new(Vec::new()),
});
inner.node.graph.register(inner.node.id, inner.clone());
Value { inner }
}
pub fn new(value: T) -> Self {
super::default_graph().value(value)
}
pub fn with_connect<F>(value: T, create: F) -> Computed<T>
where
F: Fn(&Value<T>) -> DropResource + 'static,
{
let value = Value::new(value);
let value_clone = value.clone();
value
.to_computed()
.when_connect(move || create(&value_clone))
}
pub fn get(&self, ctx: &Context) -> T {
self.inner.node.read(ctx, self.inner.clone());
self.inner.value.borrow().clone()
}
pub fn set(&self, value: T) {
if !self.inner.node.graph.check_write_allowed() {
return;
}
let graph = Graph {
inner: self.inner.node.graph.clone(),
};
graph.transaction(|_| {
if *self.inner.value.borrow() == value {
return;
}
*self.inner.value.borrow_mut() = value;
notify(&self.inner.events);
self.inner.node.graph.enqueue(self.inner.node.id);
});
}
pub fn change(&self, change_fn: impl FnOnce(&mut T)) {
let graph = Graph {
inner: self.inner.node.graph.clone(),
};
graph.transaction(|ctx| {
let mut value = self.get(ctx);
change_fn(&mut value);
self.set(value);
});
}
pub fn map<K: Clone + PartialEq + 'static, F: 'static + Fn(T) -> K>(
&self,
fun: F,
) -> Computed<K> {
Computed::create(self.inner.node.graph.clone(), {
let myself = self.clone();
Box::new(move |context| fun(myself.get(context)))
})
}
pub fn to_computed(&self) -> Computed<T> {
let myself = self.clone();
Computed::create(
self.inner.node.graph.clone(),
Box::new(move |context| myself.get(context)),
)
}
pub fn id(&self) -> GraphId {
GraphId::from_node(self.inner.node.id)
}
pub fn add_event(&self, callback: impl Fn(T) + 'static) -> DropResource {
let id = {
let mut next = self.inner.next_event.borrow_mut();
let id = *next;
*next += 1;
id
};
let value: Weak<ValueInner<T>> = Rc::downgrade(&self.inner);
let event = move || {
if let Some(value) = value.upgrade() {
let current = value.value.borrow().clone();
callback(current);
}
};
self.inner.events.borrow_mut().push((id, Rc::new(event)));
let inner = self.inner.clone();
DropResource::new(move || {
inner
.events
.borrow_mut()
.retain(|(event_id, _)| *event_id != id);
})
}
}
fn notify(events: &RefCell<ValueEvents>) {
if events.borrow().is_empty() {
return;
}
let events: Vec<_> = events
.borrow()
.iter()
.map(|(_, event)| event.clone())
.collect();
for event in events {
event();
}
}
impl<T: Clone + PartialEq + 'static> ToComputed<T> for Value<T> {
fn to_computed(&self) -> Computed<T> {
self.to_computed()
}
}
impl<T: Clone + PartialEq + 'static> ToComputed<T> for &Value<T> {
fn to_computed(&self) -> Computed<T> {
(*self).to_computed()
}
}