charming_fork_zephyr/series/
bar3d.rs1use serde::Serialize;
2
3use crate::{
4 datatype::{CompositeValue, DataFrame, DataPoint},
5 element::{CoordinateSystem, DimensionEncode},
6};
7
8#[derive(Serialize)]
9pub struct Bar3d {
10 #[serde(rename = "type")]
11 type_: String,
12
13 #[serde(skip_serializing_if = "Option::is_none")]
14 name: Option<String>,
15
16 #[serde(skip_serializing_if = "Option::is_none")]
17 coordinate_system: Option<CoordinateSystem>,
18
19 #[serde(skip_serializing_if = "Option::is_none")]
20 grid3d_index: Option<CompositeValue>,
21
22 #[serde(skip_serializing_if = "Option::is_none")]
23 geo3d_index: Option<CompositeValue>,
24
25 #[serde(skip_serializing_if = "Option::is_none")]
26 globe_index: Option<CompositeValue>,
27
28 #[serde(skip_serializing_if = "Option::is_none")]
29 shading: Option<String>,
30
31 #[serde(skip_serializing_if = "Option::is_none")]
32 encode: Option<DimensionEncode>,
33
34 #[serde(skip_serializing_if = "Vec::is_empty")]
35 data: DataFrame,
36}
37impl Bar3d {
38 pub fn new() -> Self {
39 Self {
40 type_: "bar3D".to_string(),
41 name: None,
42 coordinate_system: None,
43 grid3d_index: None,
44 geo3d_index: None,
45 globe_index: None,
46 shading: None,
47 encode: None,
48 data: DataFrame::new(),
49 }
50 }
51
52 pub fn name<S: Into<String>>(mut self, name: S) -> Self {
53 self.name = Some(name.into());
54 self
55 }
56
57 pub fn coordinate_system<C: Into<CoordinateSystem>>(mut self, coordinate_system: C) -> Self {
58 self.coordinate_system = Some(coordinate_system.into());
59 self
60 }
61
62 pub fn grid3d_index<C: Into<CompositeValue>>(mut self, grid3d_index: C) -> Self {
63 self.grid3d_index = Some(grid3d_index.into());
64 self
65 }
66
67 pub fn geo3d_index<C: Into<CompositeValue>>(mut self, geo3d_index: C) -> Self {
68 self.geo3d_index = Some(geo3d_index.into());
69 self
70 }
71
72 pub fn globe_index<C: Into<CompositeValue>>(mut self, globe_index: C) -> Self {
73 self.globe_index = Some(globe_index.into());
74 self
75 }
76
77 pub fn shading<S: Into<String>>(mut self, shading: S) -> Self {
78 self.shading = Some(shading.into());
79 self
80 }
81
82 pub fn encode<D: Into<DimensionEncode>>(mut self, encode: D) -> Self {
83 self.encode = Some(encode.into());
84 self
85 }
86
87 pub fn data<D: Into<DataPoint>>(mut self, data: Vec<D>) -> Self {
88 self.data = data.into_iter().map(|d| d.into()).collect();
89 self
90 }
91}