cursive_tree/model/

node.rs

use super::{super::backend::*, depth::*, kind::*, list::*, path::*, representation::*, state::*, symbol::*};

use {
    cursive::*,
    std::{borrow::*, marker::*},
};

//
// Node
//

/// Tree node.
pub struct Node<BackendT, ContextT, ErrorT, IdT, DataT> {
    /// Depth.
    pub depth: usize,

    /// Kind.
    pub kind: NodeKind,

    /// ID.
    pub id: IdT,

    /// Representation.
    pub representation: Representation,

    /// Representation size.
    ///
    /// Cached so we only have to calculate it once.
    pub representation_size: XY<usize>,

    /// State for [Branch](NodeKind::Branch) node.
    pub branch_state: BranchState,

    /// Children for [Branch](NodeKind::Branch) node.
    pub children: Option<NodeList<BackendT, ContextT, ErrorT, IdT, DataT>>,

    /// Data.
    pub data: Option<DataT>,

    backend: PhantomData<BackendT>,
    context: PhantomData<ContextT>,
    error: PhantomData<ErrorT>,
}

impl<BackendT, ContextT, ErrorT, IdT, DataT> Node<BackendT, ContextT, ErrorT, IdT, DataT>
where
    BackendT: TreeBackend<ContextT, ErrorT, IdT, DataT>,
{
    /// Constructor.
    pub fn new(depth: usize, kind: NodeKind, id: IdT, representation: Representation) -> Self {
        let representation_size = (representation.width(), 1).into();
        Self {
            depth,
            kind,
            id,
            representation,
            representation_size,
            branch_state: Default::default(),
            children: None,
            data: None,
            backend: Default::default(),
            context: Default::default(),
            error: Default::default(),
        }
    }

    /// Symbol.
    ///
    /// Its char count is always 1.
    pub fn symbol(&self, context: ContextT) -> Symbol<'_> {
        BackendT::symbol(self, context)
    }

    /// Get node at path.
    pub fn at_path(&self, path: NodePath) -> Option<&Self> {
        if path.is_empty() { Some(self) } else { self.children.as_ref().and_then(|children| children.at_path(path)) }
    }

    /// Get node at path.
    pub fn at_path_mut(&mut self, path: NodePath) -> Option<&mut Self> {
        if path.is_empty() {
            Some(self)
        } else {
            self.children.as_mut().and_then(|children| children.at_path_mut(path))
        }
    }

    /// Fill path to node.
    ///
    /// Returns true if found.
    pub fn fill_path(&self, path: &mut NodePath, node: &Self) -> bool {
        self.children.as_ref().map(|children| children.fill_path(path, node)).unwrap_or_default()
    }

    /// Fetch nodes from backend.
    ///
    /// If depth is [None] will populate all depths.
    ///
    /// If depth is 0 will do nothing.
    pub fn populate(&mut self, mut depth: Option<usize>, context: ContextT) -> Result<(), ErrorT>
    where
        ContextT: Clone,
    {
        if depth.is_zero() || !self.kind.is_branch() {
            return Ok(());
        }

        if self.children.is_none() {
            BackendT::populate(self, context.clone())?;
        }

        depth.decrease();
        if !depth.is_zero()
            && let Some(children) = &mut self.children
        {
            for node in children {
                node.populate(depth, context.clone())?;
            }
        }

        Ok(())
    }

    /// Add a child node.
    pub fn add_child(&mut self, kind: NodeKind, id: IdT, representation: Representation) {
        if !self.kind.is_branch() {
            return;
        }

        if self.children.is_none() {
            self.children = Some(Default::default());
        }

        self.children.as_mut().expect("children").add(self.depth + 1, kind, id, representation);
    }

    /// Inserts a child node.
    pub fn insert_child(&mut self, index: usize, kind: NodeKind, id: IdT, representation: Representation) {
        if !self.kind.is_branch() {
            return;
        }

        if self.children.is_none() {
            self.children = Some(Default::default());
        }

        self.children.as_mut().expect("children").insert(index, self.depth + 1, kind, id, representation);
    }

    /// Expand the branch.
    ///
    /// Will return false if not a [Branch](NodeKind::Branch) or already expanded.
    pub fn expand_branch(&mut self, context: ContextT) -> Result<bool, ErrorT>
    where
        ContextT: Clone,
    {
        if !self.kind.is_branch() || self.branch_state.is_expanded() {
            return Ok(false);
        }

        self.populate(Some(1), context)?;
        self.branch_state = BranchState::Expanded;
        Ok(true)
    }

    /// Collapse the branch.
    ///
    /// Will return false if not a [Branch](NodeKind::Branch) or already collapsed.
    pub fn collapse_branch(&mut self) -> bool {
        if !self.kind.is_branch() || self.branch_state.is_collapsed() {
            return false;
        }

        self.branch_state = BranchState::Collapsed;
        true
    }

    /// Toggle the branch state.
    ///
    /// Expand if collapsed, collapse if expanded.
    ///
    /// Will do nothing if not a [Branch](NodeKind::Branch).
    pub fn toggle_branch_state(&mut self, context: ContextT) -> Result<(), ErrorT>
    where
        ContextT: Clone,
    {
        if !self.kind.is_branch() {
            return Ok(());
        }

        match self.branch_state {
            BranchState::Collapsed => {
                self.expand_branch(context)?;
            }
            BranchState::Expanded => {
                self.collapse_branch();
            }
        }

        Ok(())
    }

    /// Data.
    ///
    /// If not already cached will fetch it from the backend.
    pub fn data(&mut self, context: ContextT) -> Result<Option<Cow<'_, DataT>>, ErrorT>
    where
        DataT: Clone,
    {
        if self.data.is_none() {
            if let Some((data, cache)) = BackendT::data(self, context)? {
                if cache {
                    self.data = Some(data);
                } else {
                    return Ok(Some(Cow::Owned(data)));
                }
            }
        }

        Ok(self.data.as_ref().map(Cow::Borrowed))
    }
}