rowid 0.5.0

A time-based unique ID solution
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::{io, time::SystemTime};

use crate::{
    common::configs::{CHAR_LIST, RANDOMNESS_LENGTH},
    functions::{
        decode::{_decode, DecodeOptions},
        encode::{_encode, EncodeOptions},
        generate::{_generate, GenerateOptions},
        get_randomness::{_get_randomness, GetRandomnessOptions},
        rowid::{_rowid, RowIDOptions},
        verify::{_verify, VerifyOptions},
    },
};

pub use crate::{
    common::errors::RowIDError,
    functions::{generate::GenerateResult, verify::VerifyResult},
};

/// This function generates a 32-character unique ID
/// that is almost impossible to duplicate.
///
/// ## Example
///
/// ```no_run
/// use rowid::base::rowid;
///
/// let id: String = rowid();
/// ```
pub fn rowid() -> String {
    _rowid(RowIDOptions {
        char_list: CHAR_LIST,
        randomness_length: RANDOMNESS_LENGTH,
    })
}

/// This function encodes the timestamp in milliseconds
/// into an ID without randomness.
///
/// ## Example
///
/// ```no_run
/// use std::time::SystemTime;
/// use rowid::base::encode;
///
/// let encoded: String = encode(SystemTime::now()).unwrap();
/// ```
pub fn encode<T: Into<SystemTime>>(system_time: T) -> io::Result<String> {
    _encode(EncodeOptions {
        char_list: CHAR_LIST,
        system_time: system_time.into(),
    })
}

/// This function decodes the ID into a timestamp in milliseconds.
///
/// ## Example
///
/// ```no_run
/// use std::time::SystemTime;
/// use rowid::base::decode;
///
/// let decoded: SystemTime = decode("ABC123").unwrap();
/// ```
pub fn decode<S: AsRef<str>>(encoded: S) -> io::Result<SystemTime> {
    _decode(DecodeOptions { char_list: CHAR_LIST, encoded: encoded.as_ref() })
}

/// This function generates an ID based on the input.
///
/// ## Example
///
/// ```no_run
/// use std::time::SystemTime;
/// use rowid::base::{generate, GenerateResult};
///
/// let now: SystemTime = SystemTime::now();
/// let result: GenerateResult = generate(now, Some(22));
/// ```
pub fn generate<T: Into<SystemTime>>(
    system_time: T,
    randomness_length: Option<usize>,
) -> GenerateResult {
    _generate(GenerateOptions {
        char_list: CHAR_LIST,
        system_time: system_time.into(),
        randomness_length: match randomness_length {
            | Some(l) => l,
            | None => RANDOMNESS_LENGTH,
        },
    })
}

/// This function verifies if the ID is valid and natural.
///
/// ## Example
///
/// ```no_run
/// use rowid::base::{verify, VerifyResult};
///
/// let result: VerifyResult = verify("ABC123");
/// ```
pub fn verify<S: AsRef<str>>(encoded: S) -> VerifyResult {
    _verify(VerifyOptions { char_list: CHAR_LIST, encoded: encoded.as_ref() })
}

/// This function generates randomness.
///
/// ## Example
///
/// ```no_run
/// use rowid::base::get_randomness;
///
/// let randomness: String = get_randomness(10);
/// ```
pub fn get_randomness(randomness_length: usize) -> String {
    _get_randomness(GetRandomnessOptions {
        char_list: CHAR_LIST,
        randomness_length,
    })
}