Struct DependentWeave 

pub struct DependentWeave<K, T, M, S>
where
    K: Hash + Copy + Eq + Ord,
    S: BuildHasher + Default + Clone,
{
    pub metadata: M,
    /* private fields */
}

A tree-based Weave where each Node depends on the contents of the previous Node.

For best performance, it is recommended that you use random node identifiers and the Hasher implementation from the nohash-hasher crate. If your node identifiers end with random data (such as ULIDs in their raw representation), use the hash_hasher crate instead.

Fields

metadata: M

The metadata associated with the weave.

Implementations

impl<K, T, M, S> DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

pub fn new(metadata: M) -> Self

Creates a new, empty DependentWeave.

Contracts

Post-condition: ret.nodes.is_empty()

Post-condition: ret.validate()

pub fn with_capacity(capacity: usize, metadata: M) -> Self

Creates a new, empty DependentWeave with at least the specified capacity.

This function over-allocates for worst-case memory usage rather than average-case.

Contracts

Post-condition: ret.nodes.is_empty()

Post-condition: ret.validate()

pub fn capacity(&self) -> usize

Returns the worst-case number of nodes that the weave can hold without reallocating.

May be lower than self.len().

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more nodes.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the weave as much as possible.

impl<K, T, M, S> DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

pub fn validate(&self) -> bool

Validates that the weave is internally consistent.

Trait Implementations

impl<K, T, M, S> ActionableWeave<K, DependentNode<K, T, S>, T, M, S> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: IndependentContents + DiscreteContents, S: BuildHasher + Default + Clone,

fn apply(&mut self, action: WeaveAction<K, DependentNode<K, T, S>, T, M>)

Applies a WeaveAction to a Weave.

impl<K, T, M, S> ActiveSingularWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn active(&self) -> Option<K>

Returns the active node’s identifier, if any.

impl<K, T, M, S> Archive for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone, HashMap<K, DependentNode<K, T, S>, S>: Archive, IndexSet<K, S>: Archive, Option<K>: Archive, Skip: ArchiveWith<Scratchpad>, M: Archive,

type Archived = ArchivedDependentWeave<K, T, M, S>

The archived representation of this type.

type Resolver = DependentWeaveResolver<K, T, M, S>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<K, T, M, S> BookmarkableWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn set_bookmarked(&mut self, id: &K, value: bool) -> bool

Contracts

Post-condition: ! ret || value == self.bookmarked.contains(id)

Post-condition: ret || old(self.bookmarked.clone()) == self.bookmarked

Post-condition: ret == self.nodes.contains_key(id)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Invariant: self.validate()

type Bookmarks = IndexSet<K, S>

Identifiers of bookmarked nodes.

fn bookmarks(&self) -> &Self::Bookmarks

Returns a reference to the identifiers of bookmarked nodes.

fn contains_bookmark(&self, id: &K) -> bool

Returns true if the Weave contains a bookmarked node with the specified identifier.

impl<K, T: Clone, M: Clone, S> Clone for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord + Clone, S: BuildHasher + Default + Clone + Clone,

fn clone(&self) -> DependentWeave<K, T, M, S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, T: Debug, M: Debug, S> Debug for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord + Debug, S: BuildHasher + Default + Clone + Debug,

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

Formats the value using the given formatter.

impl<K, T, M, S> Default for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone, M: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized, K, T, M, S> Deserialize<DependentWeave<K, T, M, S>, __D> for Archived<DependentWeave<K, T, M, S>>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone, HashMap<K, DependentNode<K, T, S>, S>: Archive, <HashMap<K, DependentNode<K, T, S>, S> as Archive>::Archived: Deserialize<HashMap<K, DependentNode<K, T, S>, S>, __D>, IndexSet<K, S>: Archive, <IndexSet<K, S> as Archive>::Archived: Deserialize<IndexSet<K, S>, __D>, Option<K>: Archive, <Option<K> as Archive>::Archived: Deserialize<Option<K>, __D>, Skip: ArchiveWith<Scratchpad> + DeserializeWith<<Skip as ArchiveWith<Scratchpad>>::Archived, Scratchpad, __D>, M: Archive, <M as Archive>::Archived: Deserialize<M, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<DependentWeave<K, T, M, S>, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<K, T, M, S> DiscreteWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: DiscreteContents, S: BuildHasher + Default + Clone,

fn split(&mut self, id: &K, at: usize, new_id: K) -> bool

Contracts

Post-condition: ! ret || old(self.nodes.len()) + 1 == self.nodes.len()

Post-condition: ! ret || self.nodes.contains_key(id)

Post-condition: ! ret || self.nodes.contains_key(&new_id)

Post-condition: ! ret || old(!self.nodes.contains_key(&new_id))

Post-condition: ! ret || self.nodes [id].to.contains(&new_id) && self.nodes [id].to.len() == 1

Post-condition: ! ret || self.nodes [&new_id].from == Some(*id)

Post-condition: ! ret || old(self.nodes.get(id).map(|n| n.to.clone())).unwrap() == self.nodes [&new_id].to

Post-condition: ret || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn merge_with_parent(&mut self, id: &K) -> Option<K>

Contracts

Post-condition: ret.is_none() || old(self.nodes.len()) - 1 == self.nodes.len()

Post-condition: ret.is_none() || ! self.nodes.contains_key(id)

Post-condition: ret.is_none() || old(self.nodes.contains_key(id))

Post-condition: ret.is_none() || ! old(self.contains_active(id)) || old(self.contains_active(id)) && self.contains_active(&ret.unwrap())

Post-condition: ret.is_none() || old(self.contains_active(id)) || old(self.nodes.get(id).and_then(|n| n.from).and_then(|p| self.nodes.get(&p)).map(|p| p.active)).unwrap() == self.nodes [&ret.unwrap()].active

Post-condition: ret.is_none() || old(self.nodes.get(id).and_then(|n| n.from).and_then(|p| self.nodes.get(&p)).map(|p| p.from)).unwrap() == self.nodes [&ret.unwrap()].from

Post-condition: ret.is_none() || old(self.nodes.get(id).map(|node| node.to.clone())).unwrap() == self.nodes [&ret.unwrap()].to

Post-condition: ret.is_none() || ret.unwrap() == old(self.nodes.get(id).and_then(|node| node.from)).unwrap()

Post-condition: ret.is_some() || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: ret.is_some() || old(self.active) == self.active

Post-condition: ret.is_some() || old(self.bookmarked.clone()) == self.bookmarked

Post-condition: old(self.roots.clone()) == self.roots

Invariant: self.validate()

impl<K, T, M, S> Eq for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: Eq, M: Eq, S: BuildHasher + Default + Clone,

impl<K, T, M, S> From<DependentWeave<K, T, M, S>> for IndependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: IndependentContents, S: BuildHasher + Default + Clone,

fn from(value: DependentWeave<K, T, M, S>) -> Self

Converts to this type from the input type.

impl<K, T, M, S> Layouter<DependentWeave<K, T, M, S>, K, DependentNode<K, T, S>, T, Vec2, ArrayVec<[Vec2; 6]>> for DependentLayouter<K>

where K: Hash + Copy + Eq + Ord + 'static, S: BuildHasher + Default + Clone + 'static,

fn layout( &mut self, weave: &mut DependentWeave<K, T, M, S>, sizes: impl FnMut(&K) -> Vec2, )

Arranges a Weave’s content for graphical rendering using a closure which maps Nodes to their dimensions.

fn size(&self) -> Vec2

Returns the size of the bounding box enclosing the arrangement’s content.

fn view( &mut self, min: Vec2, max: Vec2, callback: impl FnMut(LayoutItem<K, Vec2, ArrayVec<[Vec2; 6]>>), )

Returns LayoutItems within the specified bounds in the order that they should be rendered.

impl<K, T, M, S> MetadataWeave<K, DependentNode<K, T, S>, T, M> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn metadata_mut<O>(&mut self, callback: impl FnOnce(&mut M) -> O) -> O

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn metadata(&self) -> &M

Returns a reference to the Weave’s associated metadata.

impl<K, T, M, S> PartialEq for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: PartialEq, M: PartialEq, S: BuildHasher + Default + Clone,

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<K, T, M, S> SemiIndependentWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: IndependentContents, S: BuildHasher + Default + Clone,

fn get_contents_mut<O>( &mut self, id: &K, callback: impl FnOnce(&mut T) -> O, ) -> Option<O>

Contracts

Post-condition: ret.is_some() == old(self.nodes.contains_key(id))

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

impl<__S: Fallible + ?Sized, K, T, M, S> Serialize<__S> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone, HashMap<K, DependentNode<K, T, S>, S>: Serialize<__S>, IndexSet<K, S>: Serialize<__S>, Option<K>: Serialize<__S>, Skip: SerializeWith<Scratchpad, __S>, M: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<K, T, M, S> SortableBookmarkableWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn sort_bookmarks_by( &mut self, cmp: impl FnMut(&DependentNode<K, T, S>, &DependentNode<K, T, S>) -> Ordering, )

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_bookmarks_by_id(&mut self, cmp: impl FnMut(&K, &K) -> Ordering)

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

impl<K, T, M, S> SortableWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn sort_children_by( &mut self, id: &K, cmp: impl FnMut(&DependentNode<K, T, S>, &DependentNode<K, T, S>) -> Ordering, ) -> bool

Contracts

Post-condition: ret == self.nodes.contains_key(id)

Post-condition: old(self.nodes.get(id).map(|n| n.to.clone())) == self.nodes.get(id).map(|n| n.to.clone())

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_children_by_id( &mut self, id: &K, cmp: impl FnMut(&K, &K) -> Ordering, ) -> bool

Contracts

Post-condition: ret == self.nodes.contains_key(id)

Post-condition: old(self.nodes.get(id).map(|n| n.to.clone())) == self.nodes.get(id).map(|n| n.to.clone())

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_roots_by( &mut self, cmp: impl FnMut(&DependentNode<K, T, S>, &DependentNode<K, T, S>) -> Ordering, )

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_roots_by_id(&mut self, cmp: impl FnMut(&K, &K) -> Ordering)

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

impl<K, T, M, S> TryFrom<IndependentWeave<K, T, M, S>> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: IndependentContents, S: BuildHasher + Default + Clone,

type Error = IndependentWeave<K, T, M, S>

The type returned in the event of a conversion error.

fn try_from(value: IndependentWeave<K, T, M, S>) -> Result<Self, Self::Error>

Performs the conversion.

impl<K, T, M, S> Weave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn get_ordered_identifiers(&mut self, output: &mut Vec<K>)

Contracts

Post-condition: output.len() == self.nodes.len()

Post-condition: valid_topological_sort(&self.nodes, output)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn get_ordered_identifiers_from(&mut self, id: &K, output: &mut Vec<K>)

Contracts

Post-condition: lacks_duplicates(output)

Post-condition: ! self.nodes.contains_key(id) || output.first() == Some(id)

Post-condition: self.nodes.contains_key(id) || output.is_empty()

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn get_active_path(&mut self, output: &mut Vec<K>)

Contracts

Post-condition: self.active == output.first().copied()

Post-condition: lacks_duplicates(output)

Post-condition: valid_path(&self.nodes, output)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn get_path_from(&mut self, id: &K, output: &mut Vec<K>)

Contracts

Post-condition: ! self.nodes.contains_key(id) || output.first() == Some(id)

Post-condition: self.nodes.contains_key(id) || output.is_empty()

Post-condition: lacks_duplicates(output)

Post-condition: valid_path(&self.nodes, output)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn insert(&mut self, node: DependentNode<K, T, S>) -> bool

Contracts

Post-condition: ! ret || old(self.nodes.len()) + 1 == self.nodes.len()

Post-condition: ! ret || old(!self.nodes.contains_key(&node.id))

Post-condition: ! ret || self.nodes.contains_key(&old(node.id))

Post-condition: ! ret || old(node.active) == (self.active == Some(old(node.id)))

Post-condition: ! ret || old(node.bookmarked) == self.bookmarked.contains(&old(node.id))

Post-condition: ! ret || old(node.from.is_some()) || self.roots.contains(&old(node.id))

Post-condition: ! ret || old(node.from.is_none()) || old(self.roots.clone()) == self.roots

Post-condition: ret || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: ret || old(self.roots.clone()) == self.roots

Post-condition: ret || old(self.active) == self.active

Post-condition: ret || old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn set_active(&mut self, id: &K, value: bool) -> bool

Contracts

Post-condition: ! ret || value == self.contains_active(id)

Post-condition: ret || old(self.active) == self.active

Post-condition: ret == self.nodes.contains_key(id)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn remove(&mut self, id: &K) -> Option<DependentNode<K, T, S>>

Contracts

Post-condition: ! self.nodes.contains_key(id)

Post-condition: ret.is_some() == old(self.nodes.contains_key(id))

Post-condition: ret.as_ref().is_none_or(|node| &node.id == id)

Post-condition: ret.is_none() || old(self.nodes.len()) > self.nodes.len()

Post-condition: ret.is_none() || old(self.bookmarked.len()) >= self.bookmarked.len()

Post-condition: ret.is_some() || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: ret.is_some() || old(self.roots.clone()) == self.roots

Post-condition: ret.is_some() || old(self.active) == self.active

Post-condition: ret.is_some() || old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn remove_tracked( &mut self, id: &K, on_removal: impl FnMut(DependentNode<K, T, S>), ) -> bool

Contracts

Post-condition: ! self.nodes.contains_key(id)

Post-condition: ret == old(self.nodes.contains_key(id))

Post-condition: ! ret || old(self.nodes.len()) > self.nodes.len()

Post-condition: ! ret || old(self.bookmarked.len()) >= self.bookmarked.len()

Post-condition: ret || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: ret || old(self.roots.clone()) == self.roots

Post-condition: ret || old(self.active) == self.active

Post-condition: ret || old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn clear(&mut self)

Contracts

Post-condition: self.nodes.is_empty()

Post-condition: self.validate()

type Nodes = HashMap<K, DependentNode<K, T, S>, S>

Mapping between identifiers and nodes.

type Roots = IndexSet<K, S>

Identifiers of root nodes (nodes which do not have any parents) without duplicates.

fn len(&self) -> usize

Returns the number of nodes stored within the Weave.

fn is_empty(&self) -> bool

Returns true if the Weave does not contain any nodes.

fn nodes(&self) -> &Self::Nodes

Returns a reference to the identifier:node mapping.

fn roots(&self) -> &Self::Roots

Returns a reference to the identifiers of root nodes (nodes which do not have any parents).

fn contains(&self, id: &K) -> bool

Returns true if the Weave contains a node with the specified identifier.

fn contains_active(&self, id: &K) -> bool

Returns true if the Weave contains an active node (node.is_active() == true) with the specified identifier.

fn get(&self, id: &K) -> Option<&DependentNode<K, T, S>>

Returns a reference to the node corresponding to the identifier.

fn get_parents(&self, id: &K) -> Option<&Option<K>>

Convenience method for self.get(id).map(Node::from).

fn get_children(&self, id: &K) -> Option<&IndexSet<K, S>>

Convenience method for self.get(id).map(Node::to).

fn get_contents(&self, id: &K) -> Option<&T>

Convenience method for self.get(id).map(Node::contents).