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

//! Export task queue management.
#![allow(dead_code)]

/// A single export task.
#[allow(dead_code)]
#[derive(Clone, Debug)]
pub struct ExportTask2 {
    pub format: String,
    pub path: String,
    pub priority: u32,
}

/// A queue of export tasks.
#[allow(dead_code)]
pub struct ExportQueue2 {
    pub tasks: std::collections::VecDeque<ExportTask2>,
}

/// Create a new, empty export queue.
#[allow(dead_code)]
pub fn new_export_queue2() -> ExportQueue2 {
    ExportQueue2 { tasks: std::collections::VecDeque::new() }
}

/// Enqueue a task.
#[allow(dead_code)]
pub fn enqueue_task2(queue: &mut ExportQueue2, task: ExportTask2) {
    queue.tasks.push_back(task);
}

/// Dequeue the next task.
#[allow(dead_code)]
pub fn dequeue_task2(queue: &mut ExportQueue2) -> Option<ExportTask2> {
    queue.tasks.pop_front()
}

/// Get queue length.
#[allow(dead_code)]
pub fn queue2_len(queue: &ExportQueue2) -> usize {
    queue.tasks.len()
}

/// Check if queue is empty.
#[allow(dead_code)]
pub fn queue2_is_empty(queue: &ExportQueue2) -> bool {
    queue.tasks.is_empty()
}

/// Clear all tasks.
#[allow(dead_code)]
pub fn clear_queue2(queue: &mut ExportQueue2) {
    queue.tasks.clear();
}

/// Get the format of a task.
#[allow(dead_code)]
pub fn task2_format(task: &ExportTask2) -> &str {
    &task.format
}

/// Get the path of a task.
#[allow(dead_code)]
pub fn task2_path(task: &ExportTask2) -> &str {
    &task.path
}

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

    fn make_task(fmt: &str, path: &str) -> ExportTask2 {
        ExportTask2 { format: fmt.to_string(), path: path.to_string(), priority: 0 }
    }

    #[test]
    fn test_new_queue_empty() {
        let q = new_export_queue2();
        assert!(queue2_is_empty(&q));
    }

    #[test]
    fn test_enqueue_task() {
        let mut q = new_export_queue2();
        enqueue_task2(&mut q, make_task("glb", "/out/a.glb"));
        assert_eq!(queue2_len(&q), 1);
    }

    #[test]
    fn test_dequeue_task() {
        let mut q = new_export_queue2();
        enqueue_task2(&mut q, make_task("obj", "/out/b.obj"));
        let t = dequeue_task2(&mut q).expect("should succeed");
        assert_eq!(task2_format(&t), "obj");
    }

    #[test]
    fn test_dequeue_empty() {
        let mut q = new_export_queue2();
        assert!(dequeue_task2(&mut q).is_none());
    }

    #[test]
    fn test_queue_len() {
        let mut q = new_export_queue2();
        enqueue_task2(&mut q, make_task("stl", "/a.stl"));
        enqueue_task2(&mut q, make_task("ply", "/b.ply"));
        assert_eq!(queue2_len(&q), 2);
    }

    #[test]
    fn test_clear_queue() {
        let mut q = new_export_queue2();
        enqueue_task2(&mut q, make_task("glb", "/c.glb"));
        clear_queue2(&mut q);
        assert!(queue2_is_empty(&q));
    }

    #[test]
    fn test_task_path() {
        let t = make_task("fbx", "/out/mesh.fbx");
        assert_eq!(task2_path(&t), "/out/mesh.fbx");
    }

    #[test]
    fn test_fifo_order() {
        let mut q = new_export_queue2();
        enqueue_task2(&mut q, make_task("a", "/a"));
        enqueue_task2(&mut q, make_task("b", "/b"));
        let first = dequeue_task2(&mut q).expect("should succeed");
        assert_eq!(first.format, "a");
    }

    #[test]
    fn test_task_priority() {
        let t = ExportTask2 { format: "glb".to_string(), path: "/x.glb".to_string(), priority: 5 };
        assert_eq!(t.priority, 5);
    }
}