Enum SkeletonNode 

pub enum SkeletonNode {
    Dispatch {
        id: u16,
        parent_id: Option<u16>,
        child_ids: Vec<u16>,
        name: String,
        original_key: String,
        ordering: Option<SubBranchOrdering>,
    },
    Aggregate {
        id: u16,
        parent_id: Option<u16>,
        child_ids: Vec<u16>,
        name: String,
        original_key: String,
        ordering: Option<SubBranchOrdering>,
    },
    LeafHolder {
        id: u16,
        parent_id: Option<u16>,
        leaf_count: u16,
        capstone: bool,
        name: String,
        original_key: String,
        ordering: Option<SubBranchOrdering>,
    },
}

A single node in our skeleton, identified by:

• id (u16)
• optional parent_id
• a mandatory name
• an optional original_key (defaults to name if unset)
• an optional ordering (sub-branch ordering)

We store it as an enum with three variants corresponding to how sub-branches (if any) are used:

1. Dispatch: has child nodes but no leaves. Semantically, we pick exactly one branch among its children (like an enum).

2. Aggregate: has child nodes but no leaves. Semantically, we include all branches simultaneously (like a struct).

3. LeafHolder: has no child nodes but does store a leaf_count (the number of leaves), plus a capstone flag if relevant. No children are directly attached—only leaves.

The BFS or measurement logic can still do node.child_ids()—this returns &[] if it’s a LeafHolder (no children) or the actual child list if it’s Dispatch or Aggregate. Similarly, node.leaf_count() is zero for Dispatch/Aggregate and nonzero only for LeafHolder.

Variants

Dispatch

Dispatch: no leaves, but has child nodes. Semantically we pick exactly one sub-branch at runtime.

Fields

id: u16

Unique numeric ID for BFS, etc.

parent_id: Option<u16>

Optional parent in numeric form

child_ids: Vec<u16>

A list of child node IDs

name: String

Required name. Must not be empty

original_key: String

Defaults to name if not explicitly set

ordering: Option<SubBranchOrdering>

Sub-branch ordering approach

Aggregate

Aggregate: has children but no leaves. Semantically, we include all sub-branches simultaneously.

Fields

id: u16

Unique numeric ID

parent_id: Option<u16>

Optional parent

child_ids: Vec<u16>

Child node IDs

name: String

Required name

original_key: String

Defaults to name if unset

ordering: Option<SubBranchOrdering>

Sub-branch ordering

LeafHolder

LeafHolder: no children, but does store a leaf_count plus an optional capstone.

Fields

id: u16

Numeric ID

parent_id: Option<u16>

Optional parent

leaf_count: u16

Number of leaves for BFS/measurement

capstone: bool

Whether this node is special or “capstone”

name: String

Required name

original_key: String

Original key if it differs from name

ordering: Option<SubBranchOrdering>

Ordering (not always relevant for leaves, but we keep it for uniformity)

Implementations

impl SkeletonNode

pub fn id(&self) -> u16

Getter for the id field, common across all variants.

pub fn parent_id(&self) -> Option<u16>

Getter for the optional parent_id field.

pub fn name(&self) -> &str

Getter for the name field.

pub fn original_key(&self) -> &str

Getter for the original_key field.

pub fn ordering(&self) -> Option<&SubBranchOrdering>

Getter for the optional ordering field.

pub fn child_ids(&self) -> &[u16]

Getter for child_ids. Returns empty slice if variant has no children.

pub fn leaf_count(&self) -> u16

Getter for leaf_count. Returns 0 if not a LeafHolder.

pub fn capstone(&self) -> bool

Getter for capstone. Returns false if not a LeafHolder.

impl SkeletonNode

pub fn set_child_ids(&mut self, new_child_ids: Vec<u16>)

Mutate child_ids, turning this node into Dispatch if needed. If new_child_ids is empty, we switch to LeafHolder with leaf_count=0.

impl SkeletonNode

pub fn set_leaf_count(&mut self, new_count: u16)

Mutate leaf_count, turning this node into LeafHolder if needed.

Trait Implementations

impl Clone for SkeletonNode

fn clone(&self) -> SkeletonNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SkeletonNode

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

Formats the value using the given formatter.

impl Default for SkeletonNode

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SkeletonNode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl LoadFromFile for SkeletonNode

where SkeletonNode: for<'de> Deserialize<'de>,

type Error = SaveLoadError

fn load_from_file<'async_trait>( filename: impl 'async_trait + AsRef<Path> + Send, ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait,

impl PartialEq for SkeletonNode

fn eq(&self, other: &SkeletonNode) -> 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 SaveToFile for SkeletonNode

where SkeletonNode: Serialize,

type Error = SaveLoadError

fn save_to_file<'life0, 'async_trait>( &'life0 self, filename: impl 'async_trait + AsRef<Path> + Send, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl Serialize for SkeletonNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SkeletonNode