sakurai 0.1.1

Performant, general-purpose data structures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

#![no_std]
#![recursion_limit = "2048"]
#![allow(internal_features)]
#![allow(incomplete_features)]
#![forbid(unsafe_op_in_unsafe_fn)]
#![feature(core_intrinsics)]
#![feature(generic_const_exprs)]
#![doc = include_str!("../README.md")]

//! =====================================================
//!
//! ███████╗ █████╗ ██╗  ██╗██╗   ██╗██████╗  █████╗ ██╗
//! ██╔════╝██╔══██╗██║ ██╔╝██║   ██║██╔══██╗██╔══██╗██║
//! ███████╗███████║█████╔╝ ██║   ██║██████╔╝███████║██║
//! ╚════██║██╔══██║██╔═██╗ ██║   ██║██╔══██╗██╔══██║██║
//! ███████║██║  ██║██║  ██╗╚██████╔╝██║  ██║██║  ██║██║
//! ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝
//!
//! =====================================================

#[cfg(test)]
extern crate std;

pub mod btree;
//pub mod fibonacci;
pub mod fixedvec;
pub mod hashmap;
pub mod pivot;
pub mod queue;
pub mod ring;
pub mod stack;

pub use btree::BTree;
//pub use fibonacci::FibonacciHeap;
pub use fixedvec::FixedVec;
pub use hashmap::HashMap;
pub use pivot::{Pivot, PivotBuffer};
pub use queue::Queue;
pub use ring::RingBuffer;
pub use stack::Stack;

/// Mirror of the `vec!` macro, for creating a `FixedVec` with initial values.
///
/// # Example
///
/// ```
/// use sakurai::fixedvec;
///
/// let fv: FixedVec<i32, 8> = fixedvec![1, 2, 3, 4];
/// let fv2: FixedVec<i32, 8> = fixedvec![42; 3];
/// ```
#[macro_export]
macro_rules! fixedvec {
    ($($x:expr),*) => {{
        let mut fv = $crate::FixedVec::new();
        $(
            let _ = fv.push($x);
        )*
        fv
    }};
    ($elem:expr; $n:expr) => {{
        let mut fv = $crate::FixedVec::new();
        for _ in 0..$n {
            let _ = fv.push($elem);
        }
        fv
    }};
}

/// Create a HashMap with initial values.
///
/// # Example
///
/// ```
/// use sakurai::{hashmap, HashMap};
///
/// let empty: HashMap<i32, &str, 16> = hashmap! {};
///
/// let with_values: HashMap<i32, &str, 16> = hashmap! {
///     1 => "one",
///     2 => "two",
///     3 => "three"
/// };
/// ```
#[macro_export]
macro_rules! hashmap {
    {} => {{
        $crate::HashMap::new()
    }};
    { $($key:expr => $value:expr),* $(,)? } => {{
        let mut map = $crate::HashMap::new();
        $(
            let _ = map.insert($key, $value);
        )*
        map
    }};
}

#[macro_export]
macro_rules! unlikely {
    ($cond:expr) => {
        core::intrinsics::unlikely($cond)
    };
}

#[macro_export]
macro_rules! likely {
    ($cond:expr) => {
        core::intrinsics::likely($cond)
    };
}