Struct depends::InputNode

pub struct InputNode<T> { /* private fields */ }

Input Node

Input Nodes are the leaves of the graph. They wrap a value of some type T and provide a public interface to mutate it.

UpdateInput

To construct an input node, the value must implement the UpdateInput trait. This specifies the type of the update and how it affects the wrapped value.

Updating values

InputNode uses interior mutability to allow the wrapped value to be updated with a shared reference.

To update the value, use update. A node which can update values from outside of the graph via update.

#[derive(Value, Hash)]
struct MyType {
    inner: String,
}

impl UpdateInput for MyType {
    type Update = String;

    fn update_mut(&mut self, update: Self::Update) {
        self.inner.extend(update.chars());
    }
}

// Create an input node.
let input = InputNode::new(MyType {
    inner: "Hello, ".to_string(),
});

// Update the internal value. This will fail if the node is currently
// being written to.
input.update("world!".to_string()).unwrap();

assert_eq!(input.value().unwrap().inner, "Hello, world!");

Implementations

impl<T> InputNode<T>

where T: UpdateInput,

pub fn new(value: T) -> Rc<Self>

Wrap this leaf in a node.

pub fn new_with_id(value: T, id: usize) -> Rc<Self>

Create this node with a specified Id. Useful for tests.

pub fn update(&self, input: T::Update) -> ResolveResult<()>

The public interface to provide data to mutate the inner value via a shared reference.

pub fn value(&self) -> Result<Ref<'_, NodeState<T>>, BorrowError>

Access the inner value.

Trait Implementations

impl<T: Debug> Debug for InputNode<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Named> Identifiable for InputNode<T>

fn id(&self) -> usize

impl<T: Named> Named for InputNode<T>

fn name() -> &'static str

impl<T> Resolve for InputNode<T>

where T: UpdateInput,

type Output<'a> = Ref<'a, NodeState<T>> where Self: 'a

fn resolve(&self, visitor: &mut impl Visitor) -> ResolveResult<Self::Output<'_>>

You’re probably looking for resolve_root. This is recursively called on each node when a graph is being resolved.

fn resolve_root( &self, visitor: &mut impl Visitor ) -> ResolveResult<Self::Output<'_>>

Pass a Visitor through this node, resolve the latest version of all dependencies, reset the visitor and return this node’s output.