move datastructures to its own crate
Some checks failed
Rust CI / Test Suite (push) Failing after 3s
Rust CI / Clippy (push) Failing after 3s

This commit is contained in:
Christoph J. Scherr 2025-06-04 22:22:13 +02:00
parent 562ba1eaef
commit 8d03d41679
Signed by: PlexSheep
GPG key ID: 9EB784BB202BB7BB
6 changed files with 1 additions and 530 deletions

View file

@ -31,9 +31,8 @@ members = [
"crates/rfd-demo",
"crates/iter-prod",
"crates/tpdemo",
"crates/datastructures",
"crates/graph",
"crates/sdl-idiot"
"crates/sdl-idiot",
]
default-members = ["."]

View file

@ -1,6 +0,0 @@
[package]
name = "minitree"
version = "0.1.0"
edition = "2024"
[dependencies]

View file

@ -1,189 +0,0 @@
use std::mem;
use crate::vec::Vec;
pub const DEFAULT_DEGREE: usize = 1;
#[derive(Clone, Debug)]
pub struct BTree<T: Ord + Clone> {
root: Node<T>,
properties: BTreeProperties,
}
#[derive(Clone, Debug, Copy)]
pub struct BTreeProperties {
degree: usize,
max_keys: usize,
mid_key_index: usize,
}
#[derive(Clone, Debug)]
struct Node<T> {
keys: Vec<T>,
children: Vec<Node<T>>,
}
impl BTreeProperties {
fn new(degree: usize) -> Self {
Self {
degree,
max_keys: degree - 1,
mid_key_index: (degree - 1) / 2,
}
}
fn split_child<T: Ord + Clone>(&self, parent: &mut Node<T>, child_index: usize) {
let child = &mut parent.children[child_index];
let middle_key: T = child.keys[self.mid_key_index].clone();
let right_keys = match child.keys.split_off(self.mid_key_index).split_first() {
Some((_first, _others)) => {
// We don't need _first, as it will move to parent node.
_others.into()
}
None => Vec::<T>::with_capacity(self.max_keys),
};
let right_children = if !child.is_leaf() {
Some(child.children.split_off(self.mid_key_index + 1))
} else {
None
};
let new_child_node: Node<T> = Node::new(self.degree, Some(right_keys), right_children);
parent.keys.insert(child_index, middle_key);
parent.children.insert(child_index + 1, new_child_node);
}
fn is_maxed_out<T: Ord>(&self, node: &Node<T>) -> bool {
node.keys.len() == self.max_keys
}
fn insert_non_full<T: Ord + Clone>(&mut self, node: &mut Node<T>, key: T) {
let mut index: isize = isize::try_from(node.keys.len()).ok().unwrap() - 1;
while index >= 0 && node.keys[index as usize] >= key {
index -= 1;
}
let mut u_index: usize = usize::try_from(index + 1).ok().unwrap();
if node.is_leaf() {
// Just insert it, as we know this method will be called only when node is not full
node.keys.insert(u_index, key);
} else {
if self.is_maxed_out(&node.children[u_index]) {
self.split_child(node, u_index);
if node.keys[u_index] < key {
u_index += 1;
}
}
self.insert_non_full(&mut node.children[u_index], key);
}
}
}
impl<T> Node<T>
where
T: Ord,
{
fn new(degree: usize, keys: Option<Vec<T>>, children: Option<Vec<Node<T>>>) -> Self {
Node {
keys: match keys {
Some(keys) => keys,
None => Vec::with_capacity(degree - 1),
},
children: match children {
Some(children) => children,
None => Vec::with_capacity(degree),
},
}
}
fn is_leaf(&self) -> bool {
self.children.is_empty()
}
}
impl<T: Ord + Clone> BTree<T> {
pub fn new(branch_factor: usize) -> Self {
let degree = 2 * branch_factor;
Self {
root: Node::new(degree, None, None),
properties: BTreeProperties::new(degree),
}
}
pub fn clear(&mut self) {
self.root = Node::new(self.properties.degree, None, None);
}
pub fn insert(&mut self, key: T) {
if self.properties.is_maxed_out(&self.root) {
// Create an empty root and split the old root...
let mut new_root = Node::new(self.properties.degree, None, None);
mem::swap(&mut new_root, &mut self.root);
self.root.children.insert(0, new_root);
self.properties.split_child(&mut self.root, 0);
}
self.properties.insert_non_full(&mut self.root, key)
}
#[must_use]
pub fn has(&self, key: T) -> bool {
let mut current_node = &self.root;
loop {
match current_node.keys.binary_search(&key) {
Ok(_) => return true,
Err(idx) => {
if current_node.is_leaf() {
return false;
}
current_node = &current_node.children[idx];
}
}
}
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_create() {
let _tree = BTree::<u32>::new(DEFAULT_DEGREE);
}
#[test]
fn test_insert_easy() {
let mut tree = BTree::<u32>::new(DEFAULT_DEGREE);
let data = &[19, 125, 25, 16, 2, 73, 384, 435, 12924, 42, 125251, 2548];
for d in data {
tree.insert(*d)
}
for d in data {
assert!(tree.has(*d))
}
}
#[test]
fn test_insert_many() {
let mut tree = BTree::<u32>::new(DEFAULT_DEGREE);
let mut data = vec![19, 125, 25, 16, 2, 73, 384, 435, 12924, 42, 125251, 2548];
for _ in 0..10 {
data.extend(data.clone());
}
// data has 12288 elements here! This is a lot, but should be reasonably possible for a btree.
println!("len of data: {}", data.len());
for d in &data {
tree.insert(*d)
}
for d in &data {
assert!(tree.has(*d))
}
}
}

View file

@ -1,3 +0,0 @@
pub mod btree;
pub mod raw_vec;
pub mod vec;

View file

@ -1,70 +0,0 @@
use std::{
alloc::{self, Layout},
ptr::NonNull,
};
#[derive(Clone, Debug)]
pub(crate) struct RawVec<T> {
pub(crate) ptr: NonNull<T>,
pub(crate) capacity: usize,
}
impl<T> RawVec<T> {
pub(crate) fn new() -> Self {
Self {
ptr: NonNull::dangling(),
capacity: 0,
}
}
// See rustonomicon, chapter 9.2
pub(crate) fn grow_by(&mut self, added_capacity: usize) {
let new_cap = self.capacity + added_capacity;
// `Layout::array` checks that the number of bytes is <= usize::MAX,
// but this is redundant since old_layout.size() <= isize::MAX,
// so the `unwrap` should never fail.
let new_layout = Layout::array::<T>(new_cap).unwrap();
// Ensure that the new allocation doesn't exceed `isize::MAX` bytes.
if new_layout.size() > isize::MAX as usize {
alloc::handle_alloc_error(new_layout);
}
let new_ptr = if self.capacity == 0 {
unsafe { alloc::alloc(new_layout) }
} else {
let old_layout = Layout::array::<T>(self.capacity).unwrap();
let old_ptr = self.ptr.as_ptr() as *mut u8;
unsafe { alloc::realloc(old_ptr, old_layout, new_layout.size()) }
};
// If allocation fails, `new_ptr` will be null, in which case we abort.
self.ptr = match NonNull::new(new_ptr as *mut T) {
Some(p) => p,
None => alloc::handle_alloc_error(new_layout),
};
self.capacity = new_cap;
}
pub(crate) fn grow(&mut self) {
if self.capacity == 0 {
self.grow_by(1);
} else {
self.grow_by(self.capacity);
}
}
}
impl<T> Drop for RawVec<T> {
fn drop(&mut self) {
if self.capacity != 0 {
let layout = Layout::array::<T>(self.capacity).unwrap();
unsafe {
alloc::dealloc(self.ptr.as_ptr() as *mut u8, layout);
}
}
}
}
unsafe impl<T: Send> Send for RawVec<T> {}
unsafe impl<T: Sync> Sync for RawVec<T> {}

View file

@ -1,260 +0,0 @@
//! Custom implementation of the Vector datastructure
//!
//! Many thanks to the rustonomicon, chapter 9:
//! https://doc.rust-lang.org/nomicon/vec/vec.html
use std::{
mem,
ops::{Deref, DerefMut, Index, IndexMut},
ptr,
};
use crate::raw_vec::RawVec;
#[derive(Clone, Debug)]
pub struct Vec<T> {
used: usize,
buf: RawVec<T>,
}
impl<T> Default for Vec<T> {
fn default() -> Self {
Self::new()
}
}
impl<T> Vec<T> {
pub fn new() -> Self {
if mem::size_of::<T>() == 0 {
panic!("We're not ready to handle ZSTs");
}
Vec {
used: 0,
buf: RawVec::new(),
}
}
pub fn with_capacity(capacity: usize) -> Self {
if mem::size_of::<T>() == 0 {
panic!("We're not ready to handle ZSTs");
}
let mut v = Self::new();
v.reserve(capacity);
v
}
pub fn from_slice(data: &[T]) -> Self {
let mut v = Vec::<T>::with_capacity(data.len());
unsafe {
ptr::copy_nonoverlapping(data.as_ptr(), v.as_mut_ptr(), data.len());
}
v
}
pub fn pop(&mut self) -> Option<T> {
if self.used == 0 {
None
} else {
self.used -= 1;
unsafe { Some(ptr::read(self.buf.ptr.as_ptr().add(self.used))) }
}
}
pub fn push(&mut self, value: T) {
if self.used == self.buf.capacity {
self.buf.grow();
}
unsafe {
ptr::write(self.buf.ptr.as_ptr().add(self.used), value);
}
self.used += 1;
}
#[must_use]
pub fn len(&self) -> usize {
self.used
}
#[must_use]
pub fn capacity(&self) -> usize {
self.buf.capacity
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn insert(&mut self, index: usize, elem: T) {
// Note: `<=` because it's valid to insert after everything
// which would be equivalent to push.
assert!(index <= self.used, "index out of bounds");
if self.used == self.buf.capacity {
self.buf.grow();
}
unsafe {
// ptr::copy(src, dest, len): "copy from src to dest len elems"
ptr::copy(
self.buf.ptr.as_ptr().add(index),
self.buf.ptr.as_ptr().add(index + 1),
self.used - index,
);
ptr::write(self.buf.ptr.as_ptr().add(index), elem);
}
self.used += 1;
}
pub fn remove(&mut self, index: usize) -> T {
// Note: `<` because it's *not* valid to remove after everything
assert!(index < self.used, "index out of bounds");
unsafe {
self.used -= 1;
let result = ptr::read(self.buf.ptr.as_ptr().add(index));
ptr::copy(
self.buf.ptr.as_ptr().add(index + 1),
self.buf.ptr.as_ptr().add(index),
self.used - index,
);
result
}
}
pub fn reserve(&mut self, added_capacity: usize) {
self.buf.grow_by(added_capacity);
}
#[must_use]
pub fn split_off(&mut self, at: usize) -> Self {
let other_len = self.used - at;
let mut other = Self::with_capacity(other_len);
unsafe {
self.set_len(at);
other.set_len(other_len);
ptr::copy_nonoverlapping(self.as_ptr().add(at), other.as_mut_ptr(), other.len());
}
other
}
unsafe fn set_len(&mut self, new_length: usize) {
self.used = new_length
}
#[must_use]
pub const fn as_ptr(&self) -> *const T {
self.buf.ptr.as_ptr()
}
#[must_use]
pub const fn as_mut_ptr(&mut self) -> *mut T {
self.buf.ptr.as_ptr()
}
}
impl<T> Index<usize> for Vec<T> {
type Output = T;
#[inline]
fn index(&self, index: usize) -> &Self::Output {
Index::index(&**self, index)
}
}
impl<T> IndexMut<usize> for Vec<T> {
#[inline]
fn index_mut(&mut self, index: usize) -> &mut Self::Output {
IndexMut::index_mut(&mut **self, index)
}
}
impl<T> Deref for Vec<T> {
type Target = [T];
fn deref(&self) -> &[T] {
unsafe { std::slice::from_raw_parts(self.buf.ptr.as_ptr(), self.used) }
}
}
impl<T> DerefMut for Vec<T> {
fn deref_mut(&mut self) -> &mut [T] {
unsafe { std::slice::from_raw_parts_mut(self.buf.ptr.as_ptr(), self.used) }
}
}
impl<T> Drop for Vec<T> {
fn drop(&mut self) {
while self.pop().is_some() {}
}
}
impl<T> From<&[T]> for Vec<T> {
fn from(value: &[T]) -> Self {
Self::from_slice(value)
}
}
unsafe impl<T: Send> Send for Vec<T> {}
unsafe impl<T: Sync> Sync for Vec<T> {}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_create() {
let _v = Vec::<u64>::new();
}
#[test]
fn test_pushpop_num() {
let mut v = Vec::new();
let vals = &[19, 9, 14, 255, 19191919, 13890, 21521, 1251, 6216, 1830];
for val in vals {
v.push(*val);
}
for val in vals.iter().rev() {
assert_eq!(v.pop().unwrap(), *val);
}
}
#[test]
fn test_pushpop_str() {
let mut v = Vec::new();
let vals = &["AAAA", "ABBAB", "BBABBABBAJJJ"];
for val in vals {
v.push(*val);
}
for val in vals.iter().rev() {
assert_eq!(v.pop().unwrap(), *val);
}
}
#[test]
fn test_pushindex_num() {
let mut v = Vec::new();
let vals = &[19, 9, 14, 255, 19191919, 13890, 21521, 1251, 6216, 1830];
for val in vals {
v.push(*val);
}
for (idx, val) in vals.iter().enumerate() {
assert_eq!(v[idx], *val);
}
}
#[test]
fn test_pushindex_str() {
let mut v = Vec::new();
let vals = &["AAAA", "ABBAB", "BBABBABBAJJJ"];
for val in vals {
v.push(*val);
}
for (idx, val) in vals.iter().enumerate() {
assert_eq!(v[idx], *val);
}
}
}