idmix 0.1.0

mix the int id
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

use std::collections::HashMap;
use std::collections::VecDeque;
use std::fmt;

use crate::MAX_U56;
use crate::MAX_U64;
use crate::err::MixError;

use super::traits::EncoderDecoder;

#[derive(Debug)]
pub struct CustomEncoder{
    base:Vec<char>,
    mapping:HashMap<char,u8>
}
impl std::fmt::Display for CustomEncoder {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "base:{:?}\nmapping:{:?}", self.base, self.mapping)
    }
}
impl CustomEncoder {
    pub fn new(base:&str)->Result<Self,MixError>{
        let chars = base.chars();
        let mut obj = CustomEncoder{
            base:Vec::new(),
            mapping: HashMap::new()
        };
        let mut j = 0;
        for (i,c) in chars.enumerate(){
            if obj.mapping.contains_key(&c){
                return Err(MixError{msg: String::from(format!("{}{}", &"进制字符串中不允许有相同的字符：" , c))});
            }
            obj.base.insert(i, c);
            obj.mapping.insert(c,i as u8);
            j += 1;
        }
        if j<2{
            return Err(MixError{msg: String::from("进制必须大于2个字符，比如最小的二级制也是0和1两个字符串")});
        }
        Ok(obj)
    }
}
impl EncoderDecoder for CustomEncoder {
    fn encode(&self, id:u64)->Result<String,MixError> {
        let mut result = VecDeque::new();
        let b = self.base.len() as u64;
        let mut n = id;
        while n > 0 {
            let quotient = n / b;
            let remainder = n % b;

            // 将余数转换为字符,并添加到结果字符串的最前面
            result.push_front(self.base[remainder as usize] as char);
            
            n = quotient;
        }
        
        // 如果结果为空,则原数为 0
        if result.is_empty() {
            result.push_front(self.base[0] as char);
        }
        
        // 返回结果
        let s: String = result.into_iter().collect();
        Ok(String::from(s))
    }
    fn decode(&self, str:String)->Result<u64,MixError> {
        let mut result = 0u128;
        let base = self.mapping.len() as u128;
    
        let chars: Vec<char> = str.chars().collect();
        let length = chars.len();
    
        for (index, char) in chars.iter().enumerate() {
          let value = self.mapping.get(char);
          if value.is_none() {
            return Err(MixError{msg: String::from(format!("无效字符:{}",  char))});
          }
          let value = value.unwrap();
          let position = length - index - 1;
          result += base.pow(position as u32) * (*value as u128);
        }
    
        if result > MAX_U64 as u128 {
            return Err(MixError{msg: String::from(format!("字符串[ {} ]，转成的整数[ {} ]，已超出最大整数范围：[0,{}]",  str, result, MAX_U56))});
        }
    
        Ok(result as u64)
      
    }
}