···

       
17
       
 
       
use crate::{

     

       
18
       
 
       
    db::{EventRecord, NsidHit, block},

     

       
19
       
 
       
    error::AppResult,

     

       
20
       
-
       
    utils::{

     

       
21
       
-
       
        CLOCK, DefaultRateTracker, RateTracker, ReadVariableExt, WritableByteView,

     

       
22
       
-
       
        varints_unsigned_encoded,

     

       
23
       
-
       
    },

     

       
24
       
 
       
};

     

       
25
       
 
       


     

       
26
       
 
       
pub type ItemDecoder = block::ItemDecoder<Cursor<Slice>, NsidHit>;

     

       
27
       
-
       
pub type ItemEncoder = block::ItemEncoder<WritableByteView, NsidHit>;

     

       
28
       
 
       
pub type Item = block::Item<NsidHit>;

     

       
29
       
 
       


     

       
30
       
 
       
pub struct Block {

     

       
31
       
 
       
    pub written: usize,

     

       
32
       
 
       
    pub key: ByteView,

     

       
33
       
-
       
    pub data: ByteView,

     

       
34
       
 
       
}

     

       
35
       
 
       


     

       
36
       
 
       
pub struct LexiconHandle {

     
···

       
184
       
 
       
            )

     

       
185
       
 
       
            .into());

     

       
186
       
 
       
        }

     

       
187
       
-
       
        let mut writer = ItemEncoder::new(

     

       
188
       
-
       
            WritableByteView::with_size(ItemEncoder::encoded_len(count)),

     

       
189
       
-
       
            count,

     

       
190
       
-
       
        );

     

       
191
       
 
       
        let mut start_timestamp = None;

     

       
192
       
 
       
        let mut end_timestamp = None;

     

       
193
       
 
       
        let mut written = 0_usize;

     
···

       
212
       
 
       
            return Ok(Block {

     

       
213
       
 
       
                written,

     

       
214
       
 
       
                key,

     

       
215
       
-
       
                data: value.into_inner(),

     

       
216
       
 
       
            });

     

       
217
       
 
       
        }

     

       
218
       
 
       
        Err(std::io::Error::new(std::io::ErrorKind::WriteZero, "no items are in queue").into())

     

···

       
17
       
 
       
use crate::{

     

       
18
       
 
       
    db::{EventRecord, NsidHit, block},

     

       
19
       
 
       
    error::AppResult,

     

       
20
       
+
       
    utils::{CLOCK, DefaultRateTracker, RateTracker, ReadVariableExt, varints_unsigned_encoded},

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
21
       
 
       
};

     

       
22
       
 
       


     

       
23
       
 
       
pub type ItemDecoder = block::ItemDecoder<Cursor<Slice>, NsidHit>;

     

       
24
       
+
       
pub type ItemEncoder = block::ItemEncoder<Vec<u8>, NsidHit>;

     

       
25
       
 
       
pub type Item = block::Item<NsidHit>;

     

       
26
       
 
       


     

       
27
       
 
       
pub struct Block {

     

       
28
       
 
       
    pub written: usize,

     

       
29
       
 
       
    pub key: ByteView,

     

       
30
       
+
       
    pub data: Vec<u8>,

     

       
31
       
 
       
}

     

       
32
       
 
       


     

       
33
       
 
       
pub struct LexiconHandle {

     
···

       
181
       
 
       
            )

     

       
182
       
 
       
            .into());

     

       
183
       
 
       
        }

     

       
184
       
+
       
        let mut writer =

     

       
185
       
+
       
            ItemEncoder::new(Vec::with_capacity(ItemEncoder::encoded_len(count)), count);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
186
       
 
       
        let mut start_timestamp = None;

     

       
187
       
 
       
        let mut end_timestamp = None;

     

       
188
       
 
       
        let mut written = 0_usize;

     
···

       
207
       
 
       
            return Ok(Block {

     

       
208
       
 
       
                written,

     

       
209
       
 
       
                key,

     

       
210
       
+
       
                data: value,

     

       
211
       
 
       
            });

     

       
212
       
 
       
        }

     

       
213
       
 
       
        Err(std::io::Error::new(std::io::ErrorKind::WriteZero, "no items are in queue").into())