rowid/
base.rs

1use std::{io, time::SystemTime};
2
3use crate::{
4    common::configs::{CHAR_LIST, RANDOMNESS_LENGTH},
5    functions::{
6        decode::{_decode, DecodeOptions},
7        encode::{_encode, EncodeOptions},
8        generate::{_generate, GenerateOptions},
9        get_randomness::{_get_randomness, GetRandomnessOptions},
10        rowid::{_rowid, RowIDOptions},
11        verify::{_verify, VerifyOptions},
12    },
13};
14
15pub use crate::{
16    common::errors::RowIDError,
17    functions::{generate::GenerateResult, verify::VerifyResult},
18};
19
20/// This function generates a 32-character unique ID
21/// that is almost impossible to duplicate.
22///
23/// ## Example
24///
25/// ```no_run
26/// use rowid::base::rowid;
27///
28/// let id: String = rowid();
29/// ```
30pub fn rowid() -> String {
31    _rowid(RowIDOptions {
32        char_list: CHAR_LIST,
33        randomness_length: RANDOMNESS_LENGTH,
34    })
35}
36
37/// This function encodes the timestamp in milliseconds
38/// into an ID without randomness.
39///
40/// ## Example
41///
42/// ```no_run
43/// use std::time::SystemTime;
44/// use rowid::base::encode;
45///
46/// let encoded: String = encode(SystemTime::now()).unwrap();
47/// ```
48pub fn encode<T: Into<SystemTime>>(system_time: T) -> io::Result<String> {
49    _encode(EncodeOptions {
50        char_list: CHAR_LIST,
51        system_time: system_time.into(),
52    })
53}
54
55/// This function decodes the ID into a timestamp in milliseconds.
56///
57/// ## Example
58///
59/// ```no_run
60/// use std::time::SystemTime;
61/// use rowid::base::decode;
62///
63/// let decoded: SystemTime = decode("ABC123").unwrap();
64/// ```
65pub fn decode<S: AsRef<str>>(encoded: S) -> io::Result<SystemTime> {
66    _decode(DecodeOptions { char_list: CHAR_LIST, encoded: encoded.as_ref() })
67}
68
69/// This function generates an ID based on the input.
70///
71/// ## Example
72///
73/// ```no_run
74/// use std::time::SystemTime;
75/// use rowid::base::{generate, GenerateResult};
76///
77/// let now: SystemTime = SystemTime::now();
78/// let result: GenerateResult = generate(now, Some(22));
79/// ```
80pub fn generate<T: Into<SystemTime>>(
81    system_time: T,
82    randomness_length: Option<usize>,
83) -> GenerateResult {
84    _generate(GenerateOptions {
85        char_list: CHAR_LIST,
86        system_time: system_time.into(),
87        randomness_length: match randomness_length {
88            | Some(l) => l,
89            | None => RANDOMNESS_LENGTH,
90        },
91    })
92}
93
94/// This function verifies if the ID is valid and natural.
95///
96/// ## Example
97///
98/// ```no_run
99/// use rowid::base::{verify, VerifyResult};
100///
101/// let result: VerifyResult = verify("ABC123");
102/// ```
103pub fn verify<S: AsRef<str>>(encoded: S) -> VerifyResult {
104    _verify(VerifyOptions { char_list: CHAR_LIST, encoded: encoded.as_ref() })
105}
106
107/// This function generates randomness.
108///
109/// ## Example
110///
111/// ```no_run
112/// use rowid::base::get_randomness;
113///
114/// let randomness: String = get_randomness(10);
115/// ```
116pub fn get_randomness(randomness_length: usize) -> String {
117    _get_randomness(GetRandomnessOptions {
118        char_list: CHAR_LIST,
119        randomness_length,
120    })
121}