Struct NodePool 

pub struct NodePool { /* private fields */ }

线程安全的节点池封装

使用 Arc 实现快速克隆，内部使用不可变数据结构保证线程安全

Implementations

impl NodePool

pub fn new(inner: Arc<Tree>) -> Arc<NodePool>

pub fn key(&self) -> &str

获取节点池的唯一标识符

pub fn size(&self) -> usize

获取节点池中节点总数

pub fn root(&self) -> Arc<Node>

pub fn root_id(&self) -> &Box<str>

pub fn get_inner(&self) -> &Arc<Tree>

pub fn from(nodes: NodeEnum) -> Arc<NodePool>

从节点列表构建节点池

参数

• nodes - 初始节点列表
• root_id - 指定根节点ID

注意

会自动构建父子关系映射表

pub fn get_node(&self, id: &Box<str>) -> Option<Arc<Node>>

根据ID获取节点(immutable)

pub fn get_parent_node(&self, id: &Box<str>) -> Option<Arc<Node>>

pub fn contains_node(&self, id: &Box<str>) -> bool

检查节点是否存在

pub fn children( &self, parent_id: &Box<str>, ) -> Option<GenericVector<Box<str>, ArcK>>

获取直接子节点列表

pub fn descendants(&self, parent_id: &Box<str>) -> Vec<Arc<Node>>

递归获取所有子节点（深度优先）

pub fn for_each<F>(&self, id: &Box<str>, f: F)

where F: Fn(&Arc<Node>),

pub fn parent_id(&self, child_id: &Box<str>) -> Option<&Box<str>>

获取父节点ID

pub fn ancestors(&self, child_id: &Box<str>) -> Vec<Arc<Node>>

获取完整祖先链

pub fn validate_hierarchy(&self) -> Result<(), Error>

验证父子关系一致性

pub fn filter_nodes<P>(&self, predicate: P) -> Vec<Arc<Node>>

where P: Fn(&Node) -> bool,

根据类型筛选节点

pub fn find_node<P>(&self, predicate: P) -> Option<Arc<Node>>

where P: Fn(&Node) -> bool,

查找第一个匹配节点

pub fn get_node_depth(&self, node_id: &Box<str>) -> Option<usize>

获取节点在树中的深度

参数

• node_id - 目标节点ID

返回值

返回节点的深度，根节点深度为0

pub fn get_node_path(&self, node_id: &Box<str>) -> Vec<Box<str>>

获取从根节点到目标节点的完整路径

参数

• node_id - 目标节点ID

返回值

返回从根节点到目标节点的节点ID路径

pub fn resolve(&self, node_id: &Box<str>) -> Vec<Arc<Node>>

获取从根节点到目标节点的完整路径

pub fn is_leaf(&self, node_id: &Box<str>) -> bool

检查节点是否为叶子节点

参数

• node_id - 目标节点ID

返回值

如果节点不存在或没有子节点则返回 true

pub fn get_left_siblings(&self, node_id: &Box<str>) -> Vec<Box<str>>

获取左边的所有节点 根据下标

pub fn get_right_siblings(&self, node_id: &Box<str>) -> Vec<Box<str>>

获取右边边的所有节点 根据下标

pub fn get_left_nodes(&self, node_id: &Box<str>) -> Vec<Arc<Node>>

获取左边的所有节点

pub fn get_right_nodes(&self, node_id: &Box<str>) -> Vec<Arc<Node>>

获取右边的所有节点

pub fn get_all_siblings(&self, node_id: &Box<str>) -> Vec<Box<str>>

获取节点的所有兄弟节点（包括自身）

参数

• node_id - 目标节点ID

返回值

返回所有兄弟节点的ID列表（包括自身）

pub fn get_subtree_size(&self, node_id: &Box<str>) -> usize

获取节点的子树大小（包括自身和所有子节点）

参数

• node_id - 目标节点ID

返回值

返回子树中的节点总数

pub fn is_ancestor( &self, ancestor_id: &Box<str>, descendant_id: &Box<str>, ) -> bool

检查一个节点是否是另一个节点的祖先

参数

• ancestor_id - 可能的祖先节点ID
• descendant_id - 可能的后代节点ID

返回值

如果 ancestor_id 是 descendant_id 的祖先则返回 true

pub fn get_lowest_common_ancestor( &self, node1_id: &Box<str>, node2_id: &Box<str>, ) -> Option<Box<str>>

获取两个节点的最近公共祖先

参数

• node1_id - 第一个节点ID
• node2_id - 第二个节点ID

返回值

返回两个节点的最近公共祖先ID

pub fn parallel_query<P>(&self, predicate: P) -> Vec<Arc<Node>>

where P: Fn(&Node) -> bool + Send + Sync,

并行查询节点

参数

• predicate - 查询条件函数

返回值

返回所有满足条件的节点

pub fn parallel_batch_query<'a, P>( &'a self, batch_size: usize, predicate: P, ) -> Vec<Arc<Node>>

where P: Fn(&[Arc<Node>]) -> Vec<Arc<Node>> + Send + Sync,

并行批量查询节点

参数

• batch_size - 批处理大小
• predicate - 查询条件函数

返回值

返回所有满足条件的节点

pub fn parallel_query_map<'a, P, T, F>( &'a self, predicate: P, transform: F, ) -> Vec<T>

where P: Fn(&Node) -> bool + Send + Sync, F: Fn(&Arc<Node>) -> T + Send + Sync, T: Send,

并行查询并转换结果

参数

• predicate - 查询条件函数
• transform - 结果转换函数

返回值

返回转换后的结果列表

pub fn parallel_query_reduce<P, T, F>( &self, predicate: P, init: T, fold: F, ) -> T

where P: Fn(&Node) -> bool + Send + Sync, F: Fn(T, &Arc<Node>) -> T + Send + Sync, T: Send + Sync + Clone,

并行查询并聚合结果

参数

• predicate - 查询条件函数
• init - 初始值
• fold - 聚合函数

返回值

返回聚合后的结果

impl NodePool

pub fn query(&self) -> QueryEngine<'_>

创建查询引擎实例

impl NodePool

pub fn optimized_query( &self, config: QueryCacheConfig, ) -> Result<OptimizedQueryEngine, Error>

创建优化查询引擎（带缓存）

impl NodePool

pub fn lazy_query(&self, config: LazyQueryConfig) -> LazyQueryEngine

创建懒加载查询引擎

Trait Implementations

impl Clone for NodePool

fn clone(&self) -> NodePool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodePool

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodePool

fn deserialize<__D>( __deserializer: __D, ) -> Result<NodePool, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NodePool

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for NodePool

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NodePool