charming_fork_zephyr/series/
bar3d.rs

1use 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}