Struct NodeList 

pub struct NodeList<BackendT>(pub Vec<Node<BackendT>>)
where
    BackendT: TreeBackend;

Tree node list.

Tuple Fields

0: Vec<Node<BackendT>>

Implementations

impl<BackendT> NodeList<BackendT>

where BackendT: TreeBackend,

pub fn iter(&self, only_expanded: bool) -> NodeIterator<'_, BackendT>

Iterate nodes in visual order from top to bottom.

When only_expanded is true will skip the children of collapsed branches.

pub fn at_path(&self, path: NodePath) -> Option<&Node<BackendT>>

Get node at path.

pub fn at_path_mut(&mut self, path: NodePath) -> Option<&mut Node<BackendT>>

Get node at path.

pub fn fill_path(&self, path: &mut NodePath, node: &Node<BackendT>) -> bool

Fill path to node.

Returns true if found.

pub fn add( &mut self, depth: usize, kind: NodeKind, id: BackendT::ID, representation: Representation, )

Add a node.

Examples found in repository

examples/file_browser.rs (line 115)

fn node_list(depth: usize, directory: &PathBuf) -> Result<NodeList<FileBackend>, io::Error> {
    let mut list = NodeList::default();

    for entry in read_dir(directory)? {
        let entry = entry?;

        let kind = if entry.file_type()?.is_dir() { NodeKind::Branch } else { NodeKind::Leaf };

        let file_name = entry.file_name();
        let file_name = file_name.to_string_lossy();

        // We'll use different styles for leaves and branches
        let mut representation = Representation::default();
        if kind.is_branch() {
            representation.append_styled(file_name, Style::primary().combine(Effect::Bold));
        } else {
            representation.append(file_name);
        }

        list.add(depth, kind, entry.path(), representation);
    }

    list.0.sort_by(|a: &Node<FileBackend>, b: &Node<FileBackend>| a.id.cmp(&b.id));

    Ok(list)
}

pub fn insert( &mut self, index: usize, depth: usize, kind: NodeKind, id: BackendT::ID, representation: Representation, )

Insert a node.

pub fn expand( &mut self, depth: Option<usize>, context: BackendT::Context, ) -> Result<(), BackendT::Error>

where BackendT::Context: Clone,

Expand branch nodes.

If depth is None will expand all depths.

If depth is 0 will do nothing.

Note that this will populate expanded nodes from the backend.

pub fn collapse(&mut self, depth: Option<usize>)

Collapse branch nodes.

If depth is None will collapse all depths.

If depth is 0 will do nothing.

Trait Implementations

impl<BackendT> Default for NodeList<BackendT>

where BackendT: TreeBackend,

fn default() -> Self

Returns the “default value” for a type.

impl<BackendT> From<Vec<Node<BackendT>>> for NodeList<BackendT>

where BackendT: TreeBackend,

fn from(vector: Vec<Node<BackendT>>) -> Self

Converts to this type from the input type.

impl<BackendT> FromIterator<Node<BackendT>> for NodeList<BackendT>

where BackendT: TreeBackend,

fn from_iter<IteratorT>(iterator: IteratorT) -> Self

where IteratorT: IntoIterator<Item = Node<BackendT>>,

Creates a value from an iterator.

impl<'this, BackendT> IntoIterator for &'this NodeList<BackendT>

where BackendT: TreeBackend,

type Item = &'this Node<BackendT>

The type of the elements being iterated over.

type IntoIter = Iter<'this, Node<BackendT>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'this, BackendT> IntoIterator for &'this mut NodeList<BackendT>

where BackendT: TreeBackend,

type Item = &'this mut Node<BackendT>

The type of the elements being iterated over.

type IntoIter = IterMut<'this, Node<BackendT>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.