charming_fork_zephyr/series/
sunburst.rs

1use serde::{Deserialize, Serialize};
2
3use crate::element::{Emphasis, ItemStyle, Label, Sort};
4
5#[derive(Serialize)]
6#[serde(rename_all = "camelCase")]
7pub struct SunburstLevel {
8    #[serde(skip_serializing_if = "Option::is_none")]
9    r0: Option<String>,
10
11    #[serde(skip_serializing_if = "Option::is_none")]
12    r: Option<String>,
13
14    #[serde(skip_serializing_if = "Option::is_none")]
15    item_style: Option<ItemStyle>,
16
17    #[serde(skip_serializing_if = "Option::is_none")]
18    label: Option<Label>,
19}
20
21impl SunburstLevel {
22    pub fn new() -> Self {
23        Self {
24            r0: None,
25            r: None,
26            item_style: None,
27            label: None,
28        }
29    }
30
31    pub fn r0<S: Into<String>>(mut self, r0: S) -> Self {
32        self.r0 = Some(r0.into());
33        self
34    }
35
36    pub fn r<S: Into<String>>(mut self, r: S) -> Self {
37        self.r = Some(r.into());
38        self
39    }
40
41    pub fn item_style(mut self, item_style: ItemStyle) -> Self {
42        self.item_style = Some(item_style);
43        self
44    }
45
46    pub fn label(mut self, label: Label) -> Self {
47        self.label = Some(label);
48        self
49    }
50}
51
52#[derive(Serialize, Deserialize)]
53#[serde(rename_all = "camelCase")]
54pub struct SunburstNode {
55    name: String,
56
57    #[serde(skip_serializing_if = "Option::is_none")]
58    value: Option<i64>,
59
60    #[serde(skip_serializing_if = "Option::is_none")]
61    #[serde(skip_deserializing)]
62    item_style: Option<ItemStyle>,
63
64    #[serde(skip_serializing_if = "Vec::is_empty")]
65    children: Vec<SunburstNode>,
66}
67
68impl SunburstNode {
69    pub fn new<S: Into<String>>(name: S) -> Self {
70        Self {
71            name: name.into(),
72            value: None,
73            item_style: None,
74            children: vec![],
75        }
76    }
77
78    pub fn value(mut self, value: i64) -> Self {
79        self.value = Some(value);
80        self
81    }
82
83    pub fn item_style(mut self, item_style: ItemStyle) -> Self {
84        self.item_style = Some(item_style);
85        self
86    }
87
88    pub fn children(mut self, children: Vec<SunburstNode>) -> Self {
89        self.children = children;
90        self
91    }
92}
93
94impl From<&str> for SunburstNode {
95    fn from(name: &str) -> Self {
96        Self::new(name)
97    }
98}
99
100impl From<(&str, i64)> for SunburstNode {
101    fn from((name, value): (&str, i64)) -> Self {
102        Self::new(name).value(value)
103    }
104}
105
106impl From<(&str, i64, &str)> for SunburstNode {
107    fn from((name, value, color): (&str, i64, &str)) -> Self {
108        Self::new(name)
109            .value(value)
110            .item_style(ItemStyle::new().color(color))
111    }
112}
113
114#[derive(Serialize)]
115#[serde(rename_all = "camelCase")]
116pub struct Sunburst {
117    #[serde(rename = "type")]
118    type_: String,
119
120    #[serde(skip_serializing_if = "Option::is_none")]
121    id: Option<String>,
122
123    #[serde(skip_serializing_if = "Option::is_none")]
124    name: Option<String>,
125
126    #[serde(skip_serializing_if = "Option::is_none")]
127    z_level: Option<u64>,
128
129    #[serde(skip_serializing_if = "Option::is_none")]
130    z: Option<u64>,
131
132    #[serde(skip_serializing_if = "Option::is_none")]
133    center: Option<(String, String)>,
134
135    #[serde(skip_serializing_if = "Option::is_none")]
136    radius: Option<(String, String)>,
137
138    #[serde(skip_serializing_if = "Option::is_none")]
139    emphasis: Option<Emphasis>,
140
141    #[serde(skip_serializing_if = "Option::is_none")]
142    sort: Option<Sort>,
143
144    #[serde(skip_serializing_if = "Vec::is_empty")]
145    levels: Vec<SunburstLevel>,
146
147    #[serde(skip_serializing_if = "Vec::is_empty")]
148    data: Vec<SunburstNode>,
149}
150
151impl Sunburst {
152    pub fn new() -> Self {
153        Self {
154            type_: "sunburst".to_string(),
155            id: None,
156            name: None,
157            z_level: None,
158            z: None,
159            center: None,
160            radius: None,
161            emphasis: None,
162            sort: None,
163            levels: vec![],
164            data: vec![],
165        }
166    }
167
168    pub fn id<S: Into<String>>(mut self, id: S) -> Self {
169        self.id = Some(id.into());
170        self
171    }
172
173    pub fn name<S: Into<String>>(mut self, name: S) -> Self {
174        self.name = Some(name.into());
175        self
176    }
177
178    pub fn z_level(mut self, z_level: u64) -> Self {
179        self.z_level = Some(z_level);
180        self
181    }
182
183    pub fn z(mut self, z: u64) -> Self {
184        self.z = Some(z);
185        self
186    }
187
188    pub fn center<S: Into<String>>(mut self, center: (S, S)) -> Self {
189        self.center = Some((center.0.into(), center.1.into()));
190        self
191    }
192
193    pub fn radius<S: Into<String>>(mut self, radius: (S, S)) -> Self {
194        self.radius = Some((radius.0.into(), radius.1.into()));
195        self
196    }
197
198    pub fn emphasis(mut self, emphasis: Emphasis) -> Self {
199        self.emphasis = Some(emphasis);
200        self
201    }
202
203    pub fn sort(mut self, sort: Sort) -> Self {
204        self.sort = Some(sort);
205        self
206    }
207
208    pub fn levels(mut self, levels: Vec<SunburstLevel>) -> Self {
209        self.levels = levels;
210        self
211    }
212
213    pub fn data(mut self, data: Vec<SunburstNode>) -> Self {
214        self.data = data;
215        self
216    }
217}
charming_fork_zephyr/series/sunburst.rs

charming_fork_zephyr/series/
sunburst.rs
