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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

use gzb_binary_69::Reader;
// use flume::unbounded as FlumeUnBounded;
use flume::bounded as FlumeBounded;
use flume::Receiver as FlumeReveiver;
use flume::Sender as FlumeSender;
use crate::workers::{Signal,Pointer};
// use crate::workers::Debugger;
use std::sync::Arc;
use tokio::sync::{Mutex};

//-------------------------------
//primary config
//-------------------------------

#[derive(Clone,Debug)]
pub struct Config{
    pub files:Vec<String>,
    pub min_que_size:u64,
    pub expand_size:u64,
    pub num_of_writers:u8
}

impl Config{
    pub fn new(files:Vec<String>,min_que_size:u64,expand_size:u64,num_of_writers:u8)->Config{
        Config{
            files:files,
            min_que_size:min_que_size,
            expand_size:expand_size,
            num_of_writers:num_of_writers
        }
    }
}

//-------------------------------
//messages
//-------------------------------

//-------------------------------
//dis message
//-------------------------------

pub struct DiskGetMessage{
    pub item_index:u64,
    pub map_index:u8,
    pub value_boundry:(usize,usize),//(start,end)
    pub signal:Arc<Mutex<Signal>>
}

pub struct DiskAddMessage{
    // pub debugger:Arc<Mutex<Debugger>>,
    pub start_at:u64,
    pub value:Vec<u8>,
    pub signal:Arc<Mutex<Signal>>
}

pub struct DiskRemoveMessage{
    pub boundry:(usize,usize),//(start,end)
    pub signal:Arc<Mutex<Signal>>
}

pub enum DiskMessage{
    Expand(Arc<Mutex<Signal>>),
    Add(DiskAddMessage),
    Get(DiskGetMessage),
    Remove(DiskRemoveMessage)
}

#[derive(Clone)]
pub struct DiskConfig{
    pub receiver:FlumeReveiver<DiskMessage>,
    pub path:String,
    pub frame_size:u64
}

impl DiskConfig{
    pub fn new(p:String,frame_size:u64,receiver:FlumeReveiver<DiskMessage>)->DiskConfig{
        return DiskConfig{
            receiver:receiver,
            path:p,
            frame_size:frame_size
        };
    }
}

//-------------------------------
//map message
//-------------------------------

pub struct MapAddMessage{
    pub index:u64,
    pub value:Vec<u8>,
    pub signal:Arc<Mutex<Signal>>
}

pub struct MapGetMessage{
    pub index:u64,
    pub signal:Arc<Mutex<Signal>>,
}

pub struct MapRemoveMessage{
    pub pointer:Pointer,
    pub signal:Arc<Mutex<Signal>>
}

pub enum MapMessage{
    Get(MapGetMessage),
    Add(MapAddMessage),
    Remove(MapRemoveMessage)
}

//-------------------------------
//locator message
//-------------------------------

pub struct LocatorNext{
    pub signal:Arc<Mutex<Signal>>
}

pub struct LocatorAdd{
    pub value:Vec<u8>,
    pub signal:Arc<Mutex<Signal>>
}

pub struct LocatorReset{
    pub pointer:Pointer,
    pub signal:Arc<Mutex<Signal>>
}

pub struct LocatorRemove{
    pub pointer:Pointer,
    pub signal:Arc<Mutex<Signal>>
}

pub enum LocatorMessage{
    Next(LocatorNext),
    Add(LocatorAdd),
    Reset(LocatorReset),
    Remove(LocatorRemove)
}

//-------------------------------
//map config
//-------------------------------

pub struct MapConfig{
    // pub disk_senders:HashMap<u8,FlumeSender<DiskMessage>>,
    // pub locator_sender:FlumeSender<LocatorMessage>,

    pub map_index:u8,

    pub file_path:String,
    // pub disk_sender:FlumeSender<DiskMessage>,
    pub locator_sender:FlumeSender<LocatorMessage>,

    pub receiver:FlumeReveiver<MapMessage>,
    pub reader:Reader,
    // pub items:Vec<u64>,
    // pub items_in_processing:Vec<u64>,
    pub num_of_writers:u8,
    pub min_que_size:u64,
    pub expand_size:u64,
}

impl MapConfig{
    pub fn new(
        map_index:u8,
        file_path:String,
        // disk_sender:FlumeSender<DiskMessage>,
        reader:Reader,
        locator_sender:FlumeSender<LocatorMessage>,
        // items:Vec<u64>,
        num_of_writers:u8,
        min_que_size:u64,
        expand_size:u64,
    )->(MapConfig,FlumeSender<MapMessage>){
        let (sender, receiver) = FlumeBounded(5000);
        // let (sender, receiver) = FlumeUnBounded();
        return (
            MapConfig{
                map_index:map_index,
                file_path:file_path,
                // disk_senders:HashMap::new(),
                // locator_sender:locator_sender,
                reader:reader,
                receiver:receiver,
                locator_sender:locator_sender,
                // items:items,
                num_of_writers:num_of_writers,
                min_que_size:min_que_size,
                expand_size:expand_size
                // items_in_processing:Vec::new()
            },
            sender
        );
    }
}