oxihuman-core 0.1.2

Core data structures, algorithms, and asset management for OxiHuman
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
122
123

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]

/// A unique object identifier.
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ObjectId {
    pub id: u64,
}

/// Sequential ID generator.
#[allow(dead_code)]
pub struct ObjectIdGen {
    pub next: u64,
}

/// Create a new ID generator starting at 1 (0 is reserved for null).
#[allow(dead_code)]
pub fn new_id_gen() -> ObjectIdGen {
    ObjectIdGen { next: 1 }
}

/// Generate the next unique `ObjectId`.
#[allow(dead_code)]
pub fn next_id(gen: &mut ObjectIdGen) -> ObjectId {
    let id = gen.next;
    gen.next += 1;
    ObjectId { id }
}

/// Return the raw u64 value of an `ObjectId`.
#[allow(dead_code)]
pub fn id_value(oid: &ObjectId) -> u64 {
    oid.id
}

/// Returns true if the ID represents the null (invalid) object.
#[allow(dead_code)]
pub fn id_is_null(oid: &ObjectId) -> bool {
    oid.id == 0
}

/// Return the null (invalid) `ObjectId`.
#[allow(dead_code)]
pub fn null_id() -> ObjectId {
    ObjectId { id: 0 }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn first_id_is_one() {
        let mut gen = new_id_gen();
        let id = next_id(&mut gen);
        assert_eq!(id_value(&id), 1);
    }

    #[test]
    fn ids_are_sequential() {
        let mut gen = new_id_gen();
        let a = next_id(&mut gen);
        let b = next_id(&mut gen);
        assert_eq!(id_value(&b), id_value(&a) + 1);
    }

    #[test]
    fn null_id_is_zero() {
        let nid = null_id();
        assert_eq!(id_value(&nid), 0);
    }

    #[test]
    fn null_id_is_null() {
        let nid = null_id();
        assert!(id_is_null(&nid));
    }

    #[test]
    fn generated_id_is_not_null() {
        let mut gen = new_id_gen();
        let id = next_id(&mut gen);
        assert!(!id_is_null(&id));
    }

    #[test]
    fn ten_sequential_ids() {
        let mut gen = new_id_gen();
        for i in 1u64..=10 {
            let id = next_id(&mut gen);
            assert_eq!(id_value(&id), i);
        }
    }

    #[test]
    fn ids_are_unique() {
        let mut gen = new_id_gen();
        let a = next_id(&mut gen);
        let b = next_id(&mut gen);
        assert_ne!(a, b);
    }

    #[test]
    fn null_id_not_equal_to_generated() {
        let mut gen = new_id_gen();
        let id = next_id(&mut gen);
        assert_ne!(id, null_id());
    }

    #[test]
    fn id_gen_starts_at_one() {
        let gen = new_id_gen();
        assert_eq!(gen.next, 1);
    }

    #[test]
    fn id_value_matches_struct_field() {
        let id = ObjectId { id: 42 };
        assert_eq!(id_value(&id), 42);
    }
}