rgchart 0.0.11

A library for parsing and writing rhythm game charts.
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

use wasm_bindgen::prelude::*;

pub mod errors;
pub(crate) mod models;
pub(crate) mod utils;

#[macro_use]
pub(crate) mod macros;

mod parsers;
mod writers;

pub use models::common;
pub use models::generic;
pub use models::fluxis;
pub use models::osu;
pub use models::quaver;

pub use generic::GenericManiaChart;
pub use fluxis::FscFile;
pub use osu::OsuFile;
pub use quaver::QuaFile;
pub use common::{GameMode, KeyType, Key};

#[cfg(not(target_arch = "wasm32"))]
pub mod parse {
    use crate::parsers;
    use crate::GenericManiaChart;
    use std::error::Error;

    #[inline]
    pub fn from_osu_generic(raw_chart: &str) -> Result<GenericManiaChart, Box<dyn Error>> {
        parsers::osu::from_osu_generic(raw_chart)
    }

    #[inline]
    pub fn from_sm_generic(raw_chart: &str) -> Result<GenericManiaChart, Box<dyn Error>> {
        parsers::stepmania::from_sm_generic(raw_chart)
    }

    #[inline]
    pub fn from_qua_generic(raw_chart: &str) -> Result<GenericManiaChart, Box<dyn Error>> {
        parsers::quaver::from_qua_generic(raw_chart)
    }

    #[inline]
    pub fn from_fsc_generic(raw_chart: &str) -> Result<GenericManiaChart, Box<dyn Error>> {
        parsers::fluxis::from_fsc_generic(raw_chart)
    }
}

#[cfg(not(target_arch = "wasm32"))]
pub mod write {
    use crate::writers;
    use crate::GenericManiaChart;
    use std::error::Error;

    #[inline]
    pub fn to_osu_generic(chart: &GenericManiaChart) -> Result<String, Box<dyn Error>> {
        writers::osu::to_osu_generic(chart)
    }

    #[inline]
    pub fn to_sm_generic(chart: &GenericManiaChart) -> Result<String, Box<dyn Error>> {
        writers::stepmania::to_sm_generic(chart)
    }

    #[inline]
    pub fn to_qua_generic(chart: &GenericManiaChart) -> Result<String, Box<dyn Error>> {
        writers::quaver::to_qua_generic(chart)
    }

    #[inline]
    pub fn to_fsc_generic(chart: &GenericManiaChart) -> Result<String, Box<dyn Error>> {
        writers::fluxis::to_fsc_generic(chart)
    }
}

#[cfg(target_arch = "wasm32")]
pub mod parse {
    use wasm_bindgen::prelude::*;
    use crate::parsers;
    use crate::GenericManiaChart;

    #[wasm_bindgen(js_name = parseFromOsuGeneric)]
    pub fn parse_from_osu_generic(raw_chart: &str) -> Result<GenericManiaChart, JsError> {
        parsers::osu::from_osu_generic(raw_chart)
            .map_err(|e| JsError::new(&e.to_string()))
    }

    #[wasm_bindgen(js_name = parseFromSmGeneric)]
    pub fn parse_from_sm_generic(raw_chart: &str) -> Result<GenericManiaChart, JsError> {
        parsers::stepmania::from_sm_generic(raw_chart)
            .map_err(|e| JsError::new(&e.to_string()))
    }

    #[wasm_bindgen(js_name = parseFromQuaGeneric)]
    pub fn parse_from_qua_generic(raw_chart: &str) -> Result<GenericManiaChart, JsError> {
        parsers::quaver::from_qua_generic(raw_chart)
            .map_err(|e| JsError::new(&e.to_string()))
    }

    #[wasm_bindgen(js_name = parseFromFscGeneric)]
    pub fn parse_from_fsc_generic(raw_chart: &str) -> Result<GenericManiaChart, JsError> {
        parsers::fluxis::from_fsc_generic(raw_chart)
            .map_err(|e| JsError::new(&e.to_string()))
    }
}

#[cfg(target_arch = "wasm32")]
pub mod write {
    use wasm_bindgen::prelude::*;
    use crate::writers;
    use crate::GenericManiaChart;

    #[wasm_bindgen(js_name = writeToOsuGeneric)]
    pub fn write_to_osu_generic(chart: &GenericManiaChart) -> Result<String, JsError> {
        writers::osu::to_osu_generic(chart)
            .map_err(|e| JsError::new(&e.to_string()))
    }

    #[wasm_bindgen(js_name = writeToSmGeneric)]
    pub fn write_to_sm_generic(chart: &GenericManiaChart) -> Result<String, JsError> {
        writers::stepmania::to_sm_generic(chart)
            .map_err(|e| JsError::new(&e.to_string()))
    }

    #[wasm_bindgen(js_name = writeToQuaGeneric)]
    pub fn write_to_qua_generic(chart: &GenericManiaChart) -> Result<String, JsError> {
        writers::quaver::to_qua_generic(chart)
            .map_err(|e| JsError::new(&e.to_string()))
    }

    #[wasm_bindgen(js_name = writeToFscGeneric)]
    pub fn write_to_fsc_generic(chart: &GenericManiaChart) -> Result<String, JsError> {
        writers::fluxis::to_fsc_generic(chart)
            .map_err(|e| JsError::new(&e.to_string()))
    }
}