rustque 1.1.1

this is a fast on disk perstant memeory mapped que for rust it stores Vec<u8> to a file on a disk.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::sync::Arc;
use crate::workers::{Signal,debug_error,debug_message};
use crate::config::{MapConfig,MapMessage,DiskMessage};
use tokio::sync::{Notify,Mutex};
use gzb_binary_69::parser::writer::init as BinaryWriter;

const DEBUG:bool = false;
const ERROR:bool = true;

pub async fn init(config:MapConfig){

    let mut config = config;

    loop{

        let message:MapMessage;
        match config.receiver.recv_async().await{
            Ok(m)=>{
                message = m;
            },
            Err(_)=>{
                debug_error("failed-receive_message-map.rs",ERROR);
                break;
            }
        }

        match message{
            MapMessage::Add(value)=>{
                handle_add(&mut config,value).await;
            },
            MapMessage::Print=>{
                gzb_binary_69::workers::print_last_100_pointers(&mut config.reader);
            }
        }

    }

}

async fn handle_add(config:&mut MapConfig,message:(Vec<u8>,Arc<Mutex<Signal>>,Arc<Notify>)){

    debug_message("map add message received",DEBUG);

    //find the biggest value
    let biggest_value:u64;
    if config.items.len() == 0{
        biggest_value = 1;
    } else{
        biggest_value = config.items[config.items.len()-1]+1;
    }

    config.items.push(biggest_value);

    let notify_hold = message.2.clone();
    let value_len = message.0.len();
    let build_message_body:Vec<u8>;
    match BinaryWriter(biggest_value.to_be_bytes().to_vec(),message.0){
        Ok(v)=>{
            build_message_body = v;
        },
        Err(_)=>{
            message.2.notify_waiters();
            debug_error("failed-parse-message-map.rs",ERROR);
            return;
        }
    }

    let mut index = 0;

    loop{

        let notify = notify_hold.clone();

        if index == 10000{
            // debug_message("overflow",DEBUG);
            notify.notify_waiters();
            debug_error("overflow-send-message-map.rs",ERROR);
            break;
        }

        match config.reader.fill(biggest_value.to_be_bytes().to_vec(),value_len){
            Ok(write)=>{
                // debug_message("added to map",DEBUG);
                match config.disk_sender.send_async(DiskMessage::Add((
                    write.start as u64,
                    build_message_body,
                    message.1,
                    message.2
                ))).await{
                    Ok(_)=>{
                        debug_message("disk add message sent",DEBUG);
                    },
                    Err(_)=>{
                        debug_error("failed-send-message-map.rs",ERROR);
                        notify.notify_waiters();
                    }
                }
                break;
            },
            Err(e)=>{
                if e == "full"{
                    //expand map
                    match config.reader.expand(config.frame_size.clone() as usize){
                        Ok(_)=>{},
                        Err(_)=>{
                            debug_error("failed-expand-reader-map.rs",ERROR);
                            notify.notify_waiters();
                            break;
                        }
                    }
                    //expand disk
                    let signal = Signal::new();
                    let waker = Arc::new(Notify::new());
                    let sleeper = waker.clone();
                    match config.disk_sender.send_async(DiskMessage::Expand((signal.clone(),waker))).await{
                        Ok(_)=>{},
                        Err(_)=>{
                            debug_error("failed-send_expand_message-map.rs",ERROR);
                            notify.notify_waiters();
                            break;
                        }
                    }
                    sleeper.notified().await;
                    if !Signal::check(signal).await{
                        debug_error("failed-expand-disk-map.rs",ERROR);
                        notify.notify_waiters();
                        break;
                    }
                } else {
                    debug_error("failed-reader-fill-map.rs",ERROR);
                    notify.notify_waiters();
                    break;
                }
            }//error
        }//match fill

        index += 1;

    }//loop reader fill and expand

}