89 lines
2.8 KiB
Rust
89 lines
2.8 KiB
Rust
|
|
use std::collections::HashMap;
|
|
|
|
#[derive(Debug)]
|
|
pub struct NoteBlock {
|
|
// IDs are int64 as this is the datatype of rowids in sqlite
|
|
id: i64,
|
|
first_child_id: Option<i64>,
|
|
next_sibling_id: Option<i64>,
|
|
|
|
content: String
|
|
}
|
|
|
|
impl NoteBlock {
|
|
pub fn new(id: i64, first_child_id: Option<i64>, next_sibling_id: Option<i64>, content: String) -> Self {
|
|
Self {id, first_child_id, next_sibling_id, content}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct BlockTreeNode {
|
|
// a tree of nodes, where each node refers to its block by id.
|
|
// the id is used as the key in a page's block table.
|
|
block_id: i64,
|
|
block_level: Option<usize>,
|
|
first_child_node: Option<Box<BlockTreeNode>>,
|
|
next_sibling_node: Option<Box<BlockTreeNode>>
|
|
}
|
|
|
|
impl BlockTreeNode {
|
|
pub fn new(block_id: i64) -> Self {
|
|
BlockTreeNode {
|
|
block_id,
|
|
block_level: None,
|
|
first_child_node: None,
|
|
next_sibling_node: None
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct NotePage {
|
|
title: String,
|
|
id: i64,
|
|
block_tree_root: BlockTreeNode,
|
|
|
|
block_table: HashMap<i64, NoteBlock>
|
|
}
|
|
|
|
impl NotePage {
|
|
pub fn new(title: String, id: i64, root_block: NoteBlock) -> Self {
|
|
let mut new_page = Self {
|
|
title,
|
|
id,
|
|
block_tree_root: BlockTreeNode::new(root_block.id),
|
|
block_table: HashMap::new()
|
|
};
|
|
new_page.block_tree_root.block_level = Some(0);
|
|
new_page.block_table.insert(root_block.id, root_block);
|
|
new_page
|
|
}
|
|
|
|
pub fn insert(self: &mut Self, block: NoteBlock) {
|
|
self.block_table.insert(block.id, block);
|
|
}
|
|
|
|
pub fn build_tree(self: &mut Self) {
|
|
let mut node_stack = Vec::new();
|
|
node_stack.push(&mut self.block_tree_root);
|
|
while !node_stack.is_empty() {
|
|
println!("{:?}", node_stack);
|
|
let current_node = node_stack.pop().unwrap();
|
|
let current_block = self.block_table.get(¤t_node.block_id).unwrap();
|
|
if let Some(next_sibling_id) = current_block.next_sibling_id {
|
|
let mut sibling_node = BlockTreeNode::new(next_sibling_id);
|
|
sibling_node.block_level = current_node.block_level;
|
|
current_node.next_sibling_node = Some(Box::new(sibling_node));
|
|
node_stack.push(current_node.next_sibling_node.as_mut().unwrap());
|
|
}
|
|
if let Some(first_child_id) = current_block.first_child_id {
|
|
let mut child_node = BlockTreeNode::new(first_child_id);
|
|
child_node.block_level = Some(current_node.block_level.unwrap() + 1);
|
|
current_node.first_child_node = Some(Box::new(child_node));
|
|
node_stack.push(current_node.first_child_node.as_mut().unwrap());
|
|
}
|
|
}
|
|
}
|
|
}
|