Method split

src/structures/mmap_tree/node.rs:71–133

(&mut self, b: usize)

    }

    pub fn split(&mut self, b: usize) -> Result<(K, Node<K, V>), io::Error> {
        // println!("Splitting node: {:?}", self.keys);

        match self.node_type {
            NodeType::Internal => {
                if b <= 1 || b > self.keys.len() {
                    return Err(io::Error::new(
                        io::ErrorKind::Other,
                        "Invalid split point for internal node",
                    ));
                }
                let mut sibling_keys = self.keys.split_off(b - 1);
                let median_key = sibling_keys.remove(0);

                let sibling_children = self.children.split_off(b);

                let sibling = Node {
                    keys: sibling_keys,
                    values: Vec::new(),
                    children: sibling_children,
                    max_keys: self.max_keys,
                    node_type: NodeType::Internal,
                    offset: 0, // This should be set when the node is stored
                    is_root: false,
                    parent_offset: self.parent_offset,
                };

                // println!(
                //     "Internal node split: median_key = {}, sibling_keys = {:?}",
                //     median_key, sibling.keys
                // );
                Ok((median_key, sibling))
            }
            NodeType::Leaf => {
                if b < 1 || b >= self.keys.len() {
                    return Err(io::Error::new(
                        io::ErrorKind::Other,
                        "Invalid split point for leaf node",
                    ));
                }
                let sibling_keys = self.keys.split_off(b);
                let median_key = self.keys.get(b - 1).unwrap().clone();
                let sibling_values = self.values.split_off(b);

                let sibling = Node {
                    keys: sibling_keys,
                    values: sibling_values,
                    children: Vec::new(),
                    max_keys: self.max_keys,
                    node_type: NodeType::Leaf,
                    offset: 0, // This should be set when the node is stored
                    is_root: false,
                    parent_offset: self.parent_offset,
                };

                // println!(
                //     "Leaf node split: median_key = {}, sibling_keys = {:?}",
                //     median_key, sibling.keys