rg_soundmap 0.7.0

A Rust library for managing a sound map format.
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

//! Format manifest
//!
//! It contains JSON data

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Sound {
    pub id: u16,
    pub path: String,

    /// The pitch of the note.
    /// for example, C4(= Middle C) note goes 60 in decimal. It same as MIDI standard.
    /// If it is drum sound, it follows MIDI GM Drummap.
    pub pitch: u8,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Manifest {
    /// A title of the song
    pub title: String,

    /// A list of artists
    pub artists: Vec<String>,

    /// A list of writers
    pub writers: Vec<String>,

    /// A map of path of sound file
    pub sounds: Vec<Sound>,

    pub genre: String,
}

impl Default for Manifest {
    fn default() -> Self {
        Self {
            title: "Title".to_string(),
            artists: vec!["Various Artists".to_string()],
            writers: Vec::new(),
            sounds: Vec::new(),
            genre: String::new(),
        }
    }
}

impl Manifest {
    pub fn new(title: &str, artist: &str) -> Self {
        let mut manifest = Self::default();
        manifest.title = title.to_string();
        manifest.artists = vec![artist.to_string()];
        manifest
    }

    pub fn with_artists(mut self, artists: Vec<String>) -> Self {
        self.artists = artists;
        self
    }

    pub fn with_writers(mut self, writers: Vec<String>) -> Self {
        self.writers = writers;
        self
    }

    pub fn add_artist(&mut self, artist: &str) {
        self.artists.push(artist.to_string());
    }

    pub fn add_writer(&mut self, writer: &str) {
        self.writers.push(writer.to_string());
    }

    pub fn insert_sound(&mut self, id: u16, path: &str, pitch: u8) {
        let target_pos = self.sounds.iter().position(|x| x.id == id).unwrap();
        self.sounds.insert(
            target_pos,
            Sound {
                id,
                path: path.to_string(),
                pitch,
            },
        );
    }

    pub fn push_sound(&mut self, path: &str, pitch: u8) {
        let mut ids: Vec<u16> = Vec::new();

        for sound in &self.sounds {
            ids.push(sound.id);
        }

        if self.sounds.len() == 0 {
            self.sounds.push(Sound {
                id: 0,
                path: path.to_string(),
                pitch,
            });
        } else {
            for (index, sound_id) in ids.iter().enumerate() {
                // If missing number (0:0, 1:1, '2:3', 3:4 ...)
                if index != *sound_id as usize {
                    self.sounds.push(Sound {
                        id: index as u16,
                        path: path.to_string(),
                        pitch,
                    });
                    break;
                }
                // If last index
                else if index == (ids.len() - 1) {
                    self.sounds.push(Sound {
                        id: (index as u16) + 1,
                        path: path.to_string(),
                        pitch,
                    });
                }
            }
        }
    }

    pub fn get_sound_path(&self, id: u16) -> Option<&str> {
        for s in &self.sounds {
            if s.id == id {
                return Some(&s.path);
            }
        }
        None
    }
}