cbfr 0.1.6

A buffer that run on stack, focusing on performance and speed
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use cbfr::prelude::BFRDYN;


#[allow(dead_code)]
fn demo1() {
    let mut b: BFRDYN = "Hello".into();
    println!("Before mutate: {b}");

    let containll = b.contain_str("el"); println!("Contain el: {}", containll);
    let containll = b.contain_str("l"); println!("Contain l: {}", containll);
    let containll = b.contain_str("Hel"); println!("Contain Hel: {}", containll);
    let containll = b.contain_str("ll"); println!("Contain ll: {}", containll);
    let containll = b.contain_str("lo"); println!("Contain lo: {}", containll);
    let containll = b.contain_str("Amazzing"); println!("Contain amazzing: {}", containll);

    // let mr = unsafe { b.bytes_mut() };
    // mr[0] = 'Z' as u8;
    // println!("After mutate: {b}");
    // assert_eq!("Zello", b.as_ref());

    let mr = unsafe { b.bytes_mut() };
    mr[5] = b'!';
    unsafe { b.increase_len(1); }
    println!("After mutate: {b}");
    assert_eq!("Hello!", <BFRDYN as AsRef<str>>::as_ref(&b));

    let myb = BFRDYN::withcap::<64>();
    let l = myb.capacity();
    println!("{l}");
}

#[allow(dead_code)]
fn demo2() {
    let mut b1:BFRDYN = "I love ..".into();

    b1.reverse();
    let v = b1.to_vec(' ');

    println!("{}", b1);
    println!("{:?}", v);

    let mut b2: BFRDYN<512> = BFRDYN::new();
    b2.append_str("coding!").unwrap(); 
    println!("{}", b2);

    let mut b3:BFRDYN = "cbr".into();
    let b4:BFRDYN = "eda".into();
    b3.append(b4).unwrap();

    b3.sort(); 
    println!("{}", b3);

    for b in b1.as_bytes().iter() {
        if *b == b'o' { break }
        println!("{b}")
    }

    let myb: BFRDYN = "Test".into();
    let mut by = myb.as_bytes();
    by[0] = 'Z' as u8;

    println!("myb: {myb}");
    println!("by: {by:?}");
    println!("myb: {myb:?}");
}


use std::fs::write;

fn _write_with_cbfr() {
    let sometext = "Hello world!";
    let buffer: BFRDYN = sometext.into();
    let path = std::path::Path::new("./sample.txt");

    write(path, buffer).ok();
}

const CAP: usize = 8500;

fn sort_demo() -> u128 {
    let mut data = vec![];
    for _ in 0..CAP {
        let buf: BFRDYN<32> = "ziA4xaij7M23sjK08u1)".into();
        data.push(buf);
    }
    let d = std::time::Instant::now();
    for i in data.iter_mut() { i.sort(); }
    let etime = d.elapsed().as_millis();
    println!("exec time[sort]: {etime} milliseconds");
    let last = data.pop().unwrap();
    println!("result: {}", last.as_str());
    etime
}

fn isort_demo() -> u128 {
    let mut data = vec![];
    for _ in 0..CAP {
        let buf: BFRDYN<32> = "ziA4xaij7M23sjK08u1)".into();
        data.push(buf);
    }
    let d = std::time::Instant::now();
    for i in data.iter_mut() { i.isort(); }
    let etime = d.elapsed().as_millis();
    println!("exec time[isort]: {etime} milliseconds");
    let last = data.pop().unwrap();
    println!("result: {}", last.as_str());
    etime
}

fn main() {
   //  let slice: &[u8] = "Admin123".as_bytes();
   // 
   //  let mut buf = BFRDYN::<256>::from_slice(slice);
   //  buf.auto_len();
   //  println!("{}", buf.len());
   //  println!("{}", buf.as_str());
   //  return;
   //  
   //  demo1();
   //  demo2();
   //  write_with_cbfr();

    let sorttime = sort_demo();
    let isorttime = isort_demo();
    let dif = sorttime - isorttime;
    println!("time diff: {} milliseconds", dif);
}