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

use std::collections::{HashMap, HashSet};
use std::fs;
use once_cell::sync::Lazy;

pub static DB: Lazy<sled::Db> = Lazy::new(|| {
    let dir = "./data/db";
    fs::create_dir_all(dir).unwrap();
    sled::open(dir).unwrap()
});

pub fn insert(k: &str, v: &str) -> anyhow::Result<()> {
    let kk = k.as_bytes().to_vec();
    let vv = v.as_bytes().to_vec();
    DB.insert(kk, vv)?;
    Ok(())
}

pub fn contain(k: &str) -> bool{
    let kk = k.as_bytes().to_vec();
    let existed= DB.contains_key(kk.clone());
    match existed{
        Ok(yes)=>yes,
        Err(e)=>false,
    }
}
// if k not return""

pub fn get(k: &str) -> anyhow::Result<String> {
    if !contain(k){
       return Ok("".to_string());
    }
    let res1 = DB.get(&k).expect("can not read db");
    if let Some(res2) = res1 {
        let mut res3 = vec![];
        for i in res2.iter() {
            res3.push(*i);
        }
        let res4 = String::from_utf8(res3)?;
        return Ok(res4);
    }
    Ok("".to_string())
}

pub fn remove(k: &str) -> anyhow::Result<()> {
    if contain(k){
        let kk = k.as_bytes().to_vec();
        DB.remove(kk)?;
    }
    Ok(())
}

// if k not exist or v empty ,return []

pub fn read_set(dbk: &str) -> anyhow::Result<HashSet<String>> {
    let s = {
        let a = get(dbk)?;
        let res1 = serde_json::from_str(&a);
        if let Ok(res2) = res1 {
            res2
        } else {
            let res3: HashSet<String> = HashSet::new();
            res3
        }
    };
    Ok(s)
}

pub fn update_set_from_str(dbk: &str, content: &str) -> anyhow::Result<String> {
    let mut peers = read_set(dbk)?;
    let c = content.trim().to_string();
    if c != "" {
        peers.insert(c);
    }
    let l_str = serde_json::to_string(&peers)?;
    insert(dbk, &l_str)?;
    Ok(l_str)

}


pub fn update_set_from_set(dbk: &str, l: &HashSet<String>) -> anyhow::Result<String> {
    let mut peers = read_set(dbk)?;
    for content in l {
        let c = content.trim().to_string();
        if c != "" {
            peers.insert(c);
        }
    }
    let l_str = serde_json::to_string(&peers)?;
    insert(dbk, &l_str)?;
    Ok(l_str)
}

pub fn replace_set_from_set(dbk: &str, l: &HashSet<String>) -> anyhow::Result<String> {
    remove(dbk)?;
    update_set_from_set(dbk, l)
}

pub fn del_str_in_set(dbk: &str, e: &str) -> anyhow::Result<()> {
    let mut l = read_set(dbk)?;
    l.retain(|x| x != e);
    let js = serde_json::to_string(&l)?;
    insert(dbk, &js)
}