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

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

pub struct EntityId {
    pub kind: String,
    pub value: u64,
}

pub fn new_entity_id(kind: &str, value: u64) -> EntityId {
    EntityId {
        kind: kind.to_string(),
        value,
    }
}

pub fn entity_id_to_string(id: &EntityId) -> String {
    format!("{}:{}", id.kind, id.value)
}

pub fn entity_id_parse(s: &str) -> Option<EntityId> {
    let (kind, val_str) = s.split_once(':')?;
    let value: u64 = val_str.parse().ok()?;
    Some(EntityId {
        kind: kind.to_string(),
        value,
    })
}

pub fn entity_id_is_same_kind(a: &EntityId, b: &EntityId) -> bool {
    a.kind == b.kind
}

pub fn entity_id_value(id: &EntityId) -> u64 {
    id.value
}

pub fn entity_id_kind(id: &EntityId) -> &str {
    &id.kind
}

pub fn entity_id_nil(kind: &str) -> EntityId {
    EntityId {
        kind: kind.to_string(),
        value: 0,
    }
}

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

    #[test]
    fn test_new_entity_id() {
        /* create entity id with kind and value */
        let id = new_entity_id("user", 42);
        assert_eq!(entity_id_kind(&id), "user");
        assert_eq!(entity_id_value(&id), 42);
    }

    #[test]
    fn test_to_string() {
        /* serializes to kind:value format */
        let id = new_entity_id("order", 99);
        assert_eq!(entity_id_to_string(&id), "order:99");
    }

    #[test]
    fn test_parse() {
        /* parse kind:value string */
        let id = entity_id_parse("item:123").expect("should succeed");
        assert_eq!(entity_id_kind(&id), "item");
        assert_eq!(entity_id_value(&id), 123);
    }

    #[test]
    fn test_parse_invalid() {
        /* invalid format returns None */
        assert!(entity_id_parse("nodots").is_none());
        assert!(entity_id_parse("a:notanumber").is_none());
    }

    #[test]
    fn test_same_kind() {
        /* same kind check */
        let a = new_entity_id("user", 1);
        let b = new_entity_id("user", 2);
        let c = new_entity_id("order", 1);
        assert!(entity_id_is_same_kind(&a, &b));
        assert!(!entity_id_is_same_kind(&a, &c));
    }

    #[test]
    fn test_nil() {
        /* nil entity has value 0 */
        let id = entity_id_nil("product");
        assert_eq!(entity_id_value(&id), 0);
    }

    #[test]
    fn test_roundtrip() {
        /* parse(to_string()) roundtrip */
        let id = new_entity_id("thing", 7);
        let s = entity_id_to_string(&id);
        let id2 = entity_id_parse(&s).expect("should succeed");
        assert_eq!(entity_id_value(&id2), 7);
    }
}