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

use crate::core::io_looper::{Callback, IOLooper};
use chrono::{SecondsFormat, Utc};
use once_cell::sync::Lazy;
use std::fmt::Arguments;
use std::sync::atomic::{AtomicI32, Ordering};
use std::thread::ThreadId;
use std::{process, thread};

use crate::log::{LogLevel, Logger};
struct LogWrapper {
    io_looper: IOLooper<LogWriter>,
}

struct LogWriter {
    inner_logger: Option<Box<dyn Logger>>,
}

impl LogWriter {
    fn write(&self, level: LogLevel, time: String, pid: u32, tid: ThreadId, log_str: String) {
        match &self.inner_logger {
            Some(_) => self.redirect(level, log_str),
            None => {
                println!("{} {}-{:?} {} {}", time, pid, tid, level, log_str)
            }
        }
    }

    fn redirect(&self, level: LogLevel, log_str: String) {
        let logger = self.inner_logger.as_ref().unwrap();
        match level {
            LogLevel::Error => logger.error(log_str),
            LogLevel::Warn => logger.warn(log_str),
            LogLevel::Info => logger.info(log_str),
            LogLevel::Debug => logger.debug(log_str),
            LogLevel::Verbose => logger.verbose(log_str),
            _ => {}
        }
    }
}

impl Callback for LogWriter {}

impl LogWrapper {
    fn new() -> Self {
        let log_writer = LogWriter { inner_logger: None };
        let io_looper = IOLooper::new(log_writer);
        LogWrapper { io_looper }
    }

    fn format_log(&self, level: LogLevel, tag: &str, content: Arguments) {
        let pid = process::id();
        let tid = thread::current().id();
        let time = local_time();
        let log_str = format!("[{}] {}", tag, content);
        // write log in io thread
        self.io_looper
            .post(move |writer| {
                writer.write(level, time, pid, tid, log_str);
                Ok(())
            })
            .unwrap();
    }
}

static LOG_WRAPPER: Lazy<LogWrapper> = Lazy::new(LogWrapper::new);

pub fn log(level: LogLevel, tag: &str, args: Arguments) {
    if get_log_level() < level as i32 {
        return;
    }
    LOG_WRAPPER.format_log(level, tag, args);
}

fn local_time() -> String {
    Utc::now().to_rfc3339_opts(SecondsFormat::Millis, false)
}

static LOG_LEVEL: AtomicI32 = AtomicI32::new(5);

pub fn set_log_level(level: LogLevel) {
    LOG_LEVEL.swap(level as i32, Ordering::Release);
}

pub fn get_log_level() -> i32 {
    LOG_LEVEL.load(Ordering::Acquire)
}

pub fn set_logger(log_impl: Option<Box<dyn Logger>>) {
    // Here move the log_impl to io thread
    LOG_WRAPPER
        .io_looper
        .post(|writer| {
            drop(writer.inner_logger.take());
            writer.inner_logger = log_impl;
            Ok(())
        })
        .unwrap();
}

#[allow(dead_code)]
pub fn sync() -> crate::Result<()> {
    LOG_WRAPPER.io_looper.sync()
}