oxihuman-export 0.1.2

Export pipeline for OxiHuman — glTF, COLLADA, STL, and streaming formats
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Export log tracking.
#![allow(dead_code)]

/// A single log entry for an export operation.
#[allow(dead_code)]
#[derive(Clone, Debug)]
pub struct ExportLogEntry2 {
    pub message: String,
    pub is_error: bool,
    pub timestamp_ms: u64,
}

/// An export log.
#[allow(dead_code)]
pub struct ExportLog2 {
    pub entries: Vec<ExportLogEntry2>,
}

/// Create a new empty export log.
#[allow(dead_code)]
pub fn new_export_log2() -> ExportLog2 {
    ExportLog2 { entries: Vec::new() }
}

/// Log a start event.
#[allow(dead_code)]
pub fn log2_start(log: &mut ExportLog2, path: &str) {
    log.entries.push(ExportLogEntry2 {
        message: format!("Start: {}", path),
        is_error: false,
        timestamp_ms: 0,
    });
}

/// Log a finish event.
#[allow(dead_code)]
pub fn log2_finish(log: &mut ExportLog2, path: &str) {
    log.entries.push(ExportLogEntry2 {
        message: format!("Finish: {}", path),
        is_error: false,
        timestamp_ms: 1,
    });
}

/// Log an error.
#[allow(dead_code)]
pub fn log2_error(log: &mut ExportLog2, msg: &str) {
    log.entries.push(ExportLogEntry2 {
        message: format!("Error: {}", msg),
        is_error: true,
        timestamp_ms: 0,
    });
}

/// Get the number of log entries.
#[allow(dead_code)]
pub fn log2_len(log: &ExportLog2) -> usize {
    log.entries.len()
}

/// Get entry at index.
#[allow(dead_code)]
pub fn log2_entry_at(log: &ExportLog2, i: usize) -> Option<&ExportLogEntry2> {
    log.entries.get(i)
}

/// Convert log to string.
#[allow(dead_code)]
pub fn export_log2_to_string(log: &ExportLog2) -> String {
    log.entries.iter().map(|e| e.message.clone()).collect::<Vec<_>>().join("\n")
}

/// Clear all log entries.
#[allow(dead_code)]
pub fn clear_log2(log: &mut ExportLog2) {
    log.entries.clear();
}

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

    #[test]
    fn test_new_log_empty() {
        let l = new_export_log2();
        assert_eq!(log2_len(&l), 0);
    }

    #[test]
    fn test_log_start() {
        let mut l = new_export_log2();
        log2_start(&mut l, "/out/a.glb");
        assert_eq!(log2_len(&l), 1);
    }

    #[test]
    fn test_log_finish() {
        let mut l = new_export_log2();
        log2_finish(&mut l, "/out/a.glb");
        let e = log2_entry_at(&l, 0).expect("should succeed");
        assert!(e.message.contains("Finish"));
    }

    #[test]
    fn test_log_error() {
        let mut l = new_export_log2();
        log2_error(&mut l, "file not found");
        let e = log2_entry_at(&l, 0).expect("should succeed");
        assert!(e.is_error);
    }

    #[test]
    fn test_log_entry_at_oob() {
        let l = new_export_log2();
        assert!(log2_entry_at(&l, 0).is_none());
    }

    #[test]
    fn test_export_log_to_string() {
        let mut l = new_export_log2();
        log2_start(&mut l, "/a");
        let s = export_log2_to_string(&l);
        assert!(s.contains("Start"));
    }

    #[test]
    fn test_clear_log() {
        let mut l = new_export_log2();
        log2_start(&mut l, "/x");
        clear_log2(&mut l);
        assert_eq!(log2_len(&l), 0);
    }

    #[test]
    fn test_multiple_entries() {
        let mut l = new_export_log2();
        log2_start(&mut l, "/a");
        log2_finish(&mut l, "/a");
        assert_eq!(log2_len(&l), 2);
    }

    #[test]
    fn test_log_entry_struct() {
        let e = ExportLogEntry2 { message: "ok".to_string(), is_error: false, timestamp_ms: 100 };
        assert_eq!(e.timestamp_ms, 100);
    }
}