mmkv 0.7.0

Rust version of MMKV
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

use crate::Result;
use crate::core::buffer::{Buffer, Decoder, Encoder};
use crate::core::config::Config;
use crate::core::io_looper::Callback;
use crate::core::memory_map::MemoryMap;
use std::time::Instant;

const LOG_TAG: &str = "MMKV:IO";

pub struct IOWriter {
    config: Config,
    mm: MemoryMap,
    position: u32,
    need_trim: bool,
    encoder: Box<dyn Encoder>,
    decoder: Box<dyn Decoder>,
}

impl Callback for IOWriter {}

impl IOWriter {
    pub fn new(
        config: Config,
        mm: MemoryMap,
        position: u32,
        encoder: Box<dyn Encoder>,
        decoder: Box<dyn Decoder>,
    ) -> Self {
        IOWriter {
            config,
            mm,
            position,
            need_trim: false,
            encoder,
            decoder,
        }
    }

    // Flash the data to file, always running in one io thread, so don't need lock here
    pub fn write(&mut self, buffer: Buffer, duplicated: bool) -> Result<()> {
        let data = self.encoder.encode_to_bytes(&buffer, self.position)?;
        let target_end = data.len() + self.mm.write_offset();
        let max_len = self.mm.len();
        if duplicated {
            self.need_trim = true;
        }
        if target_end <= max_len {
            self.mm.append(&data)?;
            self.position += 1;
            return Ok(());
        }
        if self.need_trim {
            // rewrite the entire map
            let time_start = Instant::now();
            info!(
                LOG_TAG,
                "start trim, current len {}",
                self.mm.write_offset()
            );
            info!(LOG_TAG, "start take snapshot");
            let (mut snapshot, _) = self
                .mm
                .iter(|bytes, position| self.decoder.decode_bytes(bytes, position))
                .into_map();
            if buffer.is_deleting() {
                snapshot.remove(buffer.key());
            } else {
                snapshot.insert(buffer.key().to_string(), buffer);
            }
            info!(LOG_TAG, "snapshot finished in {:?}", time_start.elapsed());
            self.mm.reset();
            self.position = 0;
            for buffer in snapshot.values() {
                let bytes = self.encoder.encode_to_bytes(buffer, self.position)?;
                if self.mm.write_offset() + bytes.len() > max_len {
                    self.expand()?;
                }
                self.mm.append(&bytes)?;
                self.position += 1;
            }
            self.need_trim = false;
            info!(
                LOG_TAG,
                "wrote {} items, new len {}, cost {:?}",
                self.position,
                self.mm.write_offset(),
                time_start.elapsed()
            );
        } else {
            // expand and write
            self.expand()?;
            self.mm.append(&data)?;
            self.position += 1;
        }
        Ok(())
    }

    fn expand(&mut self) -> Result<()> {
        self.config.expand()?;
        self.mm = MemoryMap::new(&self.config.file, self.config.file_size()? as usize)?;
        Ok(())
    }

    pub fn remove_file(&mut self) -> Result<()> {
        self.config.remove_file()
    }
}