#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Mesh3D<'a> {
#[serde(rename = "visible")]
#[serde(skip_serializing_if = "Option::is_none")]
visible: Option<Visible>,
#[serde(rename = "legendgroup")]
#[serde(skip_serializing_if = "Option::is_none")]
legendgroup: Option<&'a str>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
name: Option<&'a str>,
#[serde(rename = "uid")]
#[serde(skip_serializing_if = "Option::is_none")]
uid: Option<&'a str>,
#[serde(rename = "ids")]
#[serde(skip_serializing_if = "Option::is_none")]
ids: Option<&'a [&'a str]>,
#[serde(rename = "meta")]
#[serde(skip_serializing_if = "Option::is_none")]
meta: Option<crate::Any>,
#[serde(rename = "hoverlabel")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
hoverlabel: crate::IsEmpty<Hoverlabel<'a>>,
#[serde(rename = "stream")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
stream: crate::IsEmpty<Stream<'a>>,
#[serde(rename = "uirevision")]
#[serde(skip_serializing_if = "Option::is_none")]
uirevision: Option<crate::Any>,
#[serde(rename = "x")]
#[serde(skip_serializing_if = "Option::is_none")]
x: Option<&'a [f64]>,
#[serde(rename = "y")]
#[serde(skip_serializing_if = "Option::is_none")]
y: Option<&'a [f64]>,
#[serde(rename = "z")]
#[serde(skip_serializing_if = "Option::is_none")]
z: Option<&'a [f64]>,
#[serde(rename = "i")]
#[serde(skip_serializing_if = "Option::is_none")]
i: Option<&'a [f64]>,
#[serde(rename = "j")]
#[serde(skip_serializing_if = "Option::is_none")]
j: Option<&'a [f64]>,
#[serde(rename = "k")]
#[serde(skip_serializing_if = "Option::is_none")]
k: Option<&'a [f64]>,
#[serde(rename = "text")]
#[serde(skip_serializing_if = "Option::is_none")]
text: Option<&'a str>,
#[serde(rename = "hovertext")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertext: Option<&'a str>,
#[serde(rename = "hovertemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertemplate: Option<&'a str>,
#[serde(rename = "delaunayaxis")]
#[serde(skip_serializing_if = "Option::is_none")]
delaunayaxis: Option<Delaunayaxis>,
#[serde(rename = "alphahull")]
#[serde(skip_serializing_if = "Option::is_none")]
alphahull: Option<f64>,
#[serde(rename = "intensity")]
#[serde(skip_serializing_if = "Option::is_none")]
intensity: Option<&'a [f64]>,
#[serde(rename = "intensitymode")]
#[serde(skip_serializing_if = "Option::is_none")]
intensitymode: Option<Intensitymode>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
#[serde(rename = "vertexcolor")]
#[serde(skip_serializing_if = "Option::is_none")]
vertexcolor: Option<&'a [f64]>,
#[serde(rename = "facecolor")]
#[serde(skip_serializing_if = "Option::is_none")]
facecolor: Option<&'a [f64]>,
#[serde(rename = "cauto")]
#[serde(skip_serializing_if = "Option::is_none")]
cauto: Option<bool>,
#[serde(rename = "cmin")]
#[serde(skip_serializing_if = "Option::is_none")]
cmin: Option<f64>,
#[serde(rename = "cmax")]
#[serde(skip_serializing_if = "Option::is_none")]
cmax: Option<f64>,
#[serde(rename = "cmid")]
#[serde(skip_serializing_if = "Option::is_none")]
cmid: Option<f64>,
#[serde(rename = "colorscale")]
#[serde(skip_serializing_if = "Option::is_none")]
colorscale: Option<crate::ColorScale<'a>>,
#[serde(rename = "autocolorscale")]
#[serde(skip_serializing_if = "Option::is_none")]
autocolorscale: Option<bool>,
#[serde(rename = "reversescale")]
#[serde(skip_serializing_if = "Option::is_none")]
reversescale: Option<bool>,
#[serde(rename = "showscale")]
#[serde(skip_serializing_if = "Option::is_none")]
showscale: Option<bool>,
#[serde(rename = "colorbar")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
colorbar: crate::IsEmpty<Colorbar<'a>>,
#[serde(rename = "coloraxis")]
#[serde(skip_serializing_if = "Option::is_none")]
coloraxis: Option<&'a str>,
#[serde(rename = "opacity")]
#[serde(skip_serializing_if = "Option::is_none")]
opacity: Option<f64>,
#[serde(rename = "flatshading")]
#[serde(skip_serializing_if = "Option::is_none")]
flatshading: Option<bool>,
#[serde(rename = "contour")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
contour: crate::IsEmpty<Contour<'a>>,
#[serde(rename = "lightposition")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
lightposition: crate::IsEmpty<Lightposition<>>,
#[serde(rename = "lighting")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
lighting: crate::IsEmpty<Lighting<>>,
#[serde(rename = "hoverinfo")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
hoverinfo: crate::IsEmpty<Hoverinfo>,
#[serde(rename = "showlegend")]
#[serde(skip_serializing_if = "Option::is_none")]
showlegend: Option<bool>,
#[serde(rename = "xcalendar")]
#[serde(skip_serializing_if = "Option::is_none")]
xcalendar: Option<Xcalendar>,
#[serde(rename = "ycalendar")]
#[serde(skip_serializing_if = "Option::is_none")]
ycalendar: Option<Ycalendar>,
#[serde(rename = "zcalendar")]
#[serde(skip_serializing_if = "Option::is_none")]
zcalendar: Option<Zcalendar>,
#[serde(rename = "scene")]
#[serde(skip_serializing_if = "Option::is_none")]
scene: Option<&'a str>,
#[serde(rename = "idssrc")]
#[serde(skip_serializing_if = "Option::is_none")]
idssrc: Option<&'a str>,
#[serde(rename = "customdatasrc")]
#[serde(skip_serializing_if = "Option::is_none")]
customdatasrc: Option<&'a str>,
#[serde(rename = "metasrc")]
#[serde(skip_serializing_if = "Option::is_none")]
metasrc: Option<&'a str>,
#[serde(rename = "xsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
xsrc: Option<&'a str>,
#[serde(rename = "ysrc")]
#[serde(skip_serializing_if = "Option::is_none")]
ysrc: Option<&'a str>,
#[serde(rename = "zsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
zsrc: Option<&'a str>,
#[serde(rename = "isrc")]
#[serde(skip_serializing_if = "Option::is_none")]
isrc: Option<&'a str>,
#[serde(rename = "jsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
jsrc: Option<&'a str>,
#[serde(rename = "ksrc")]
#[serde(skip_serializing_if = "Option::is_none")]
ksrc: Option<&'a str>,
#[serde(rename = "textsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
textsrc: Option<&'a str>,
#[serde(rename = "hovertextsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertextsrc: Option<&'a str>,
#[serde(rename = "hovertemplatesrc")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertemplatesrc: Option<&'a str>,
#[serde(rename = "intensitysrc")]
#[serde(skip_serializing_if = "Option::is_none")]
intensitysrc: Option<&'a str>,
#[serde(rename = "vertexcolorsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
vertexcolorsrc: Option<&'a str>,
#[serde(rename = "facecolorsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
facecolorsrc: Option<&'a str>,
#[serde(rename = "hoverinfosrc")]
#[serde(skip_serializing_if = "Option::is_none")]
hoverinfosrc: Option<&'a str>,
}
impl<'a> Mesh3D<'a> {
pub fn visible(&mut self, visible: Visible) -> &mut Self {
self.visible = Some(visible);
self
}
pub fn legendgroup(&mut self, legendgroup: &'a str) -> &mut Self {
self.legendgroup = Some(legendgroup);
self
}
pub fn name(&mut self, name: &'a str) -> &mut Self {
self.name = Some(name);
self
}
pub fn uid(&mut self, uid: &'a str) -> &mut Self {
self.uid = Some(uid);
self
}
pub fn ids(&mut self, ids: &'a [&'a str]) -> &mut Self {
self.ids = Some(ids);
self
}
pub fn meta(&mut self, meta: crate::Any) -> &mut Self {
self.meta = Some(meta);
self
}
pub fn hoverlabel(&mut self) -> &mut Hoverlabel<'a> {
self.hoverlabel.is_empty = false;
&mut self.hoverlabel.data
}
pub fn stream(&mut self) -> &mut Stream<'a> {
self.stream.is_empty = false;
&mut self.stream.data
}
pub fn uirevision(&mut self, uirevision: crate::Any) -> &mut Self {
self.uirevision = Some(uirevision);
self
}
pub fn x(&mut self, x: &'a [f64]) -> &mut Self {
self.x = Some(x);
self
}
pub fn y(&mut self, y: &'a [f64]) -> &mut Self {
self.y = Some(y);
self
}
pub fn z(&mut self, z: &'a [f64]) -> &mut Self {
self.z = Some(z);
self
}
pub fn i(&mut self, i: &'a [f64]) -> &mut Self {
self.i = Some(i);
self
}
pub fn j(&mut self, j: &'a [f64]) -> &mut Self {
self.j = Some(j);
self
}
pub fn k(&mut self, k: &'a [f64]) -> &mut Self {
self.k = Some(k);
self
}
pub fn text(&mut self, text: &'a str) -> &mut Self {
self.text = Some(text);
self
}
pub fn hovertext(&mut self, hovertext: &'a str) -> &mut Self {
self.hovertext = Some(hovertext);
self
}
pub fn hovertemplate(&mut self, hovertemplate: &'a str) -> &mut Self {
self.hovertemplate = Some(hovertemplate);
self
}
pub fn delaunayaxis(&mut self, delaunayaxis: Delaunayaxis) -> &mut Self {
self.delaunayaxis = Some(delaunayaxis);
self
}
pub fn alphahull(&mut self, alphahull: f64) -> &mut Self {
self.alphahull = Some(alphahull);
self
}
pub fn intensity(&mut self, intensity: &'a [f64]) -> &mut Self {
self.intensity = Some(intensity);
self
}
pub fn intensitymode(&mut self, intensitymode: Intensitymode) -> &mut Self {
self.intensitymode = Some(intensitymode);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
pub fn vertexcolor(&mut self, vertexcolor: &'a [f64]) -> &mut Self {
self.vertexcolor = Some(vertexcolor);
self
}
pub fn facecolor(&mut self, facecolor: &'a [f64]) -> &mut Self {
self.facecolor = Some(facecolor);
self
}
pub fn cauto(&mut self, cauto: bool) -> &mut Self {
self.cauto = Some(cauto);
self
}
pub fn cmin(&mut self, cmin: f64) -> &mut Self {
self.cmin = Some(cmin);
self
}
pub fn cmax(&mut self, cmax: f64) -> &mut Self {
self.cmax = Some(cmax);
self
}
pub fn cmid(&mut self, cmid: f64) -> &mut Self {
self.cmid = Some(cmid);
self
}
pub fn colorscale(&mut self, colorscale: crate::ColorScale<'a>) -> &mut Self {
self.colorscale = Some(colorscale);
self
}
pub fn autocolorscale(&mut self, autocolorscale: bool) -> &mut Self {
self.autocolorscale = Some(autocolorscale);
self
}
pub fn reversescale(&mut self, reversescale: bool) -> &mut Self {
self.reversescale = Some(reversescale);
self
}
pub fn showscale(&mut self, showscale: bool) -> &mut Self {
self.showscale = Some(showscale);
self
}
pub fn colorbar(&mut self) -> &mut Colorbar<'a> {
self.colorbar.is_empty = false;
&mut self.colorbar.data
}
pub fn coloraxis(&mut self, coloraxis: &'a str) -> &mut Self {
self.coloraxis = Some(coloraxis);
self
}
pub fn opacity(&mut self, opacity: f64) -> &mut Self {
self.opacity = Some(opacity);
self
}
pub fn flatshading(&mut self, flatshading: bool) -> &mut Self {
self.flatshading = Some(flatshading);
self
}
pub fn contour(&mut self) -> &mut Contour<'a> {
self.contour.is_empty = false;
&mut self.contour.data
}
pub fn lightposition(&mut self) -> &mut Lightposition<> {
self.lightposition.is_empty = false;
&mut self.lightposition.data
}
pub fn lighting(&mut self) -> &mut Lighting<> {
self.lighting.is_empty = false;
&mut self.lighting.data
}
pub fn hoverinfo(&mut self) -> &mut Hoverinfo {
self.hoverinfo.is_empty = false;
&mut self.hoverinfo.data
}
pub fn showlegend(&mut self, showlegend: bool) -> &mut Self {
self.showlegend = Some(showlegend);
self
}
pub fn xcalendar(&mut self, xcalendar: Xcalendar) -> &mut Self {
self.xcalendar = Some(xcalendar);
self
}
pub fn ycalendar(&mut self, ycalendar: Ycalendar) -> &mut Self {
self.ycalendar = Some(ycalendar);
self
}
pub fn zcalendar(&mut self, zcalendar: Zcalendar) -> &mut Self {
self.zcalendar = Some(zcalendar);
self
}
pub fn scene(&mut self, scene: &'a str) -> &mut Self {
self.scene = Some(scene);
self
}
pub fn idssrc(&mut self, idssrc: &'a str) -> &mut Self {
self.idssrc = Some(idssrc);
self
}
pub fn customdatasrc(&mut self, customdatasrc: &'a str) -> &mut Self {
self.customdatasrc = Some(customdatasrc);
self
}
pub fn metasrc(&mut self, metasrc: &'a str) -> &mut Self {
self.metasrc = Some(metasrc);
self
}
pub fn xsrc(&mut self, xsrc: &'a str) -> &mut Self {
self.xsrc = Some(xsrc);
self
}
pub fn ysrc(&mut self, ysrc: &'a str) -> &mut Self {
self.ysrc = Some(ysrc);
self
}
pub fn zsrc(&mut self, zsrc: &'a str) -> &mut Self {
self.zsrc = Some(zsrc);
self
}
pub fn isrc(&mut self, isrc: &'a str) -> &mut Self {
self.isrc = Some(isrc);
self
}
pub fn jsrc(&mut self, jsrc: &'a str) -> &mut Self {
self.jsrc = Some(jsrc);
self
}
pub fn ksrc(&mut self, ksrc: &'a str) -> &mut Self {
self.ksrc = Some(ksrc);
self
}
pub fn textsrc(&mut self, textsrc: &'a str) -> &mut Self {
self.textsrc = Some(textsrc);
self
}
pub fn hovertextsrc(&mut self, hovertextsrc: &'a str) -> &mut Self {
self.hovertextsrc = Some(hovertextsrc);
self
}
pub fn hovertemplatesrc(&mut self, hovertemplatesrc: &'a str) -> &mut Self {
self.hovertemplatesrc = Some(hovertemplatesrc);
self
}
pub fn intensitysrc(&mut self, intensitysrc: &'a str) -> &mut Self {
self.intensitysrc = Some(intensitysrc);
self
}
pub fn vertexcolorsrc(&mut self, vertexcolorsrc: &'a str) -> &mut Self {
self.vertexcolorsrc = Some(vertexcolorsrc);
self
}
pub fn facecolorsrc(&mut self, facecolorsrc: &'a str) -> &mut Self {
self.facecolorsrc = Some(facecolorsrc);
self
}
pub fn hoverinfosrc(&mut self, hoverinfosrc: &'a str) -> &mut Self {
self.hoverinfosrc = Some(hoverinfosrc);
self
}
}
pub enum Visible {
True,
False,
Legendonly,
}
impl serde::Serialize for Visible {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::True => serializer.serialize_bool(true),
Self::False => serializer.serialize_bool(false),
Self::Legendonly => serializer.serialize_str("legendonly"),
}
}
}
#[derive(Default, Serialize)]
pub struct Hoverlabel<'a> {
#[serde(rename = "bgcolor")]
#[serde(skip_serializing_if = "Option::is_none")]
bgcolor: Option<&'a str>,
#[serde(rename = "bordercolor")]
#[serde(skip_serializing_if = "Option::is_none")]
bordercolor: Option<&'a str>,
#[serde(rename = "font")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
font: crate::IsEmpty<hoverlabel::Font<'a>>,
#[serde(rename = "align")]
#[serde(skip_serializing_if = "Option::is_none")]
align: Option<hoverlabel::Align>,
#[serde(rename = "namelength")]
#[serde(skip_serializing_if = "Option::is_none")]
namelength: Option<u64>,
}
impl<'a> Hoverlabel<'a> {
pub fn bgcolor(&mut self, bgcolor: &'a str) -> &mut Self {
self.bgcolor = Some(bgcolor);
self
}
pub fn bordercolor(&mut self, bordercolor: &'a str) -> &mut Self {
self.bordercolor = Some(bordercolor);
self
}
pub fn font(&mut self) -> &mut hoverlabel::Font<'a> {
self.font.is_empty = false;
&mut self.font.data
}
pub fn align(&mut self, align: hoverlabel::Align) -> &mut Self {
self.align = Some(align);
self
}
pub fn namelength(&mut self, namelength: u64) -> &mut Self {
self.namelength = Some(namelength);
self
}
}
pub mod hoverlabel {
#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Font<'a> {
#[serde(rename = "family")]
#[serde(skip_serializing_if = "Option::is_none")]
family: Option<&'a str>,
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<f64>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
}
impl<'a> Font<'a> {
pub fn family(&mut self, family: &'a str) -> &mut Self {
self.family = Some(family);
self
}
pub fn size(&mut self, size: f64) -> &mut Self {
self.size = Some(size);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
}
pub enum Align {
Left,
Right,
Auto,
}
impl serde::Serialize for Align {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Left => serializer.serialize_str("left"),
Self::Right => serializer.serialize_str("right"),
Self::Auto => serializer.serialize_str("auto"),
}
}
}
}
#[derive(Default, Serialize)]
pub struct Stream<'a> {
#[serde(rename = "token")]
#[serde(skip_serializing_if = "Option::is_none")]
token: Option<&'a str>,
#[serde(rename = "maxpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
maxpoints: Option<f64>,
}
impl<'a> Stream<'a> {
pub fn token(&mut self, token: &'a str) -> &mut Self {
self.token = Some(token);
self
}
pub fn maxpoints(&mut self, maxpoints: f64) -> &mut Self {
self.maxpoints = Some(maxpoints);
self
}
}
pub enum Delaunayaxis {
X,
Y,
Z,
}
impl serde::Serialize for Delaunayaxis {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::X => serializer.serialize_str("x"),
Self::Y => serializer.serialize_str("y"),
Self::Z => serializer.serialize_str("z"),
}
}
}
pub enum Intensitymode {
Vertex,
Cell,
}
impl serde::Serialize for Intensitymode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Vertex => serializer.serialize_str("vertex"),
Self::Cell => serializer.serialize_str("cell"),
}
}
}
#[derive(Default, Serialize)]
pub struct Colorbar<'a> {
#[serde(rename = "thicknessmode")]
#[serde(skip_serializing_if = "Option::is_none")]
thicknessmode: Option<colorbar::Thicknessmode>,
#[serde(rename = "thickness")]
#[serde(skip_serializing_if = "Option::is_none")]
thickness: Option<f64>,
#[serde(rename = "lenmode")]
#[serde(skip_serializing_if = "Option::is_none")]
lenmode: Option<colorbar::Lenmode>,
#[serde(rename = "len")]
#[serde(skip_serializing_if = "Option::is_none")]
len: Option<f64>,
#[serde(rename = "x")]
#[serde(skip_serializing_if = "Option::is_none")]
x: Option<f64>,
#[serde(rename = "xanchor")]
#[serde(skip_serializing_if = "Option::is_none")]
xanchor: Option<colorbar::Xanchor>,
#[serde(rename = "xpad")]
#[serde(skip_serializing_if = "Option::is_none")]
xpad: Option<f64>,
#[serde(rename = "y")]
#[serde(skip_serializing_if = "Option::is_none")]
y: Option<f64>,
#[serde(rename = "yanchor")]
#[serde(skip_serializing_if = "Option::is_none")]
yanchor: Option<colorbar::Yanchor>,
#[serde(rename = "ypad")]
#[serde(skip_serializing_if = "Option::is_none")]
ypad: Option<f64>,
#[serde(rename = "outlinecolor")]
#[serde(skip_serializing_if = "Option::is_none")]
outlinecolor: Option<&'a str>,
#[serde(rename = "outlinewidth")]
#[serde(skip_serializing_if = "Option::is_none")]
outlinewidth: Option<f64>,
#[serde(rename = "bordercolor")]
#[serde(skip_serializing_if = "Option::is_none")]
bordercolor: Option<&'a str>,
#[serde(rename = "borderwidth")]
#[serde(skip_serializing_if = "Option::is_none")]
borderwidth: Option<f64>,
#[serde(rename = "bgcolor")]
#[serde(skip_serializing_if = "Option::is_none")]
bgcolor: Option<&'a str>,
#[serde(rename = "tickmode")]
#[serde(skip_serializing_if = "Option::is_none")]
tickmode: Option<colorbar::Tickmode>,
#[serde(rename = "nticks")]
#[serde(skip_serializing_if = "Option::is_none")]
nticks: Option<u64>,
#[serde(rename = "tick0")]
#[serde(skip_serializing_if = "Option::is_none")]
tick_0: Option<crate::Any>,
#[serde(rename = "dtick")]
#[serde(skip_serializing_if = "Option::is_none")]
dtick: Option<crate::Any>,
#[serde(rename = "tickvals")]
#[serde(skip_serializing_if = "Option::is_none")]
tickvals: Option<&'a [f64]>,
#[serde(rename = "ticktext")]
#[serde(skip_serializing_if = "Option::is_none")]
ticktext: Option<&'a [&'a str]>,
#[serde(rename = "ticks")]
#[serde(skip_serializing_if = "Option::is_none")]
ticks: Option<colorbar::Ticks>,
#[serde(rename = "ticklen")]
#[serde(skip_serializing_if = "Option::is_none")]
ticklen: Option<f64>,
#[serde(rename = "tickwidth")]
#[serde(skip_serializing_if = "Option::is_none")]
tickwidth: Option<f64>,
#[serde(rename = "tickcolor")]
#[serde(skip_serializing_if = "Option::is_none")]
tickcolor: Option<&'a str>,
#[serde(rename = "showticklabels")]
#[serde(skip_serializing_if = "Option::is_none")]
showticklabels: Option<bool>,
#[serde(rename = "tickfont")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
tickfont: crate::IsEmpty<colorbar::Tickfont<'a>>,
#[serde(rename = "tickangle")]
#[serde(skip_serializing_if = "Option::is_none")]
tickangle: Option<crate::Angle>,
#[serde(rename = "tickformat")]
#[serde(skip_serializing_if = "Option::is_none")]
tickformat: Option<&'a str>,
#[serde(rename = "tickprefix")]
#[serde(skip_serializing_if = "Option::is_none")]
tickprefix: Option<&'a str>,
#[serde(rename = "showtickprefix")]
#[serde(skip_serializing_if = "Option::is_none")]
showtickprefix: Option<colorbar::Showtickprefix>,
#[serde(rename = "ticksuffix")]
#[serde(skip_serializing_if = "Option::is_none")]
ticksuffix: Option<&'a str>,
#[serde(rename = "showticksuffix")]
#[serde(skip_serializing_if = "Option::is_none")]
showticksuffix: Option<colorbar::Showticksuffix>,
#[serde(rename = "separatethousands")]
#[serde(skip_serializing_if = "Option::is_none")]
separatethousands: Option<bool>,
#[serde(rename = "exponentformat")]
#[serde(skip_serializing_if = "Option::is_none")]
exponentformat: Option<colorbar::Exponentformat>,
#[serde(rename = "showexponent")]
#[serde(skip_serializing_if = "Option::is_none")]
showexponent: Option<colorbar::Showexponent>,
#[serde(rename = "title")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
title: crate::IsEmpty<colorbar::Title<'a>>,
}
impl<'a> Colorbar<'a> {
pub fn thicknessmode(&mut self, thicknessmode: colorbar::Thicknessmode) -> &mut Self {
self.thicknessmode = Some(thicknessmode);
self
}
pub fn thickness(&mut self, thickness: f64) -> &mut Self {
self.thickness = Some(thickness);
self
}
pub fn lenmode(&mut self, lenmode: colorbar::Lenmode) -> &mut Self {
self.lenmode = Some(lenmode);
self
}
pub fn len(&mut self, len: f64) -> &mut Self {
self.len = Some(len);
self
}
pub fn x(&mut self, x: f64) -> &mut Self {
self.x = Some(x);
self
}
pub fn xanchor(&mut self, xanchor: colorbar::Xanchor) -> &mut Self {
self.xanchor = Some(xanchor);
self
}
pub fn xpad(&mut self, xpad: f64) -> &mut Self {
self.xpad = Some(xpad);
self
}
pub fn y(&mut self, y: f64) -> &mut Self {
self.y = Some(y);
self
}
pub fn yanchor(&mut self, yanchor: colorbar::Yanchor) -> &mut Self {
self.yanchor = Some(yanchor);
self
}
pub fn ypad(&mut self, ypad: f64) -> &mut Self {
self.ypad = Some(ypad);
self
}
pub fn outlinecolor(&mut self, outlinecolor: &'a str) -> &mut Self {
self.outlinecolor = Some(outlinecolor);
self
}
pub fn outlinewidth(&mut self, outlinewidth: f64) -> &mut Self {
self.outlinewidth = Some(outlinewidth);
self
}
pub fn bordercolor(&mut self, bordercolor: &'a str) -> &mut Self {
self.bordercolor = Some(bordercolor);
self
}
pub fn borderwidth(&mut self, borderwidth: f64) -> &mut Self {
self.borderwidth = Some(borderwidth);
self
}
pub fn bgcolor(&mut self, bgcolor: &'a str) -> &mut Self {
self.bgcolor = Some(bgcolor);
self
}
pub fn tickmode(&mut self, tickmode: colorbar::Tickmode) -> &mut Self {
self.tickmode = Some(tickmode);
self
}
pub fn nticks(&mut self, nticks: u64) -> &mut Self {
self.nticks = Some(nticks);
self
}
pub fn tick_0(&mut self, tick_0: crate::Any) -> &mut Self {
self.tick_0 = Some(tick_0);
self
}
pub fn dtick(&mut self, dtick: crate::Any) -> &mut Self {
self.dtick = Some(dtick);
self
}
pub fn tickvals(&mut self, tickvals: &'a [f64]) -> &mut Self {
self.tickvals = Some(tickvals);
self
}
pub fn ticktext(&mut self, ticktext: &'a [&'a str]) -> &mut Self {
self.ticktext = Some(ticktext);
self
}
pub fn ticks(&mut self, ticks: colorbar::Ticks) -> &mut Self {
self.ticks = Some(ticks);
self
}
pub fn ticklen(&mut self, ticklen: f64) -> &mut Self {
self.ticklen = Some(ticklen);
self
}
pub fn tickwidth(&mut self, tickwidth: f64) -> &mut Self {
self.tickwidth = Some(tickwidth);
self
}
pub fn tickcolor(&mut self, tickcolor: &'a str) -> &mut Self {
self.tickcolor = Some(tickcolor);
self
}
pub fn showticklabels(&mut self, showticklabels: bool) -> &mut Self {
self.showticklabels = Some(showticklabels);
self
}
pub fn tickfont(&mut self) -> &mut colorbar::Tickfont<'a> {
self.tickfont.is_empty = false;
&mut self.tickfont.data
}
pub fn tickangle(&mut self, tickangle: crate::Angle) -> &mut Self {
self.tickangle = Some(tickangle);
self
}
pub fn tickformat(&mut self, tickformat: &'a str) -> &mut Self {
self.tickformat = Some(tickformat);
self
}
pub fn tickprefix(&mut self, tickprefix: &'a str) -> &mut Self {
self.tickprefix = Some(tickprefix);
self
}
pub fn showtickprefix(&mut self, showtickprefix: colorbar::Showtickprefix) -> &mut Self {
self.showtickprefix = Some(showtickprefix);
self
}
pub fn ticksuffix(&mut self, ticksuffix: &'a str) -> &mut Self {
self.ticksuffix = Some(ticksuffix);
self
}
pub fn showticksuffix(&mut self, showticksuffix: colorbar::Showticksuffix) -> &mut Self {
self.showticksuffix = Some(showticksuffix);
self
}
pub fn separatethousands(&mut self, separatethousands: bool) -> &mut Self {
self.separatethousands = Some(separatethousands);
self
}
pub fn exponentformat(&mut self, exponentformat: colorbar::Exponentformat) -> &mut Self {
self.exponentformat = Some(exponentformat);
self
}
pub fn showexponent(&mut self, showexponent: colorbar::Showexponent) -> &mut Self {
self.showexponent = Some(showexponent);
self
}
pub fn title(&mut self) -> &mut colorbar::Title<'a> {
self.title.is_empty = false;
&mut self.title.data
}
}
pub mod colorbar {
#[allow(unused_imports)]
use serde::Serialize;
pub enum Thicknessmode {
Fraction,
Pixels,
}
impl serde::Serialize for Thicknessmode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Fraction => serializer.serialize_str("fraction"),
Self::Pixels => serializer.serialize_str("pixels"),
}
}
}
pub enum Lenmode {
Fraction,
Pixels,
}
impl serde::Serialize for Lenmode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Fraction => serializer.serialize_str("fraction"),
Self::Pixels => serializer.serialize_str("pixels"),
}
}
}
pub enum Xanchor {
Left,
Center,
Right,
}
impl serde::Serialize for Xanchor {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Left => serializer.serialize_str("left"),
Self::Center => serializer.serialize_str("center"),
Self::Right => serializer.serialize_str("right"),
}
}
}
pub enum Yanchor {
Top,
Middle,
Bottom,
}
impl serde::Serialize for Yanchor {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Top => serializer.serialize_str("top"),
Self::Middle => serializer.serialize_str("middle"),
Self::Bottom => serializer.serialize_str("bottom"),
}
}
}
pub enum Tickmode {
Auto,
Linear,
Array,
}
impl serde::Serialize for Tickmode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Auto => serializer.serialize_str("auto"),
Self::Linear => serializer.serialize_str("linear"),
Self::Array => serializer.serialize_str("array"),
}
}
}
pub enum Ticks {
Outside,
Inside,
}
impl serde::Serialize for Ticks {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Outside => serializer.serialize_str("outside"),
Self::Inside => serializer.serialize_str("inside"),
}
}
}
#[derive(Default, Serialize)]
pub struct Tickfont<'a> {
#[serde(rename = "family")]
#[serde(skip_serializing_if = "Option::is_none")]
family: Option<&'a str>,
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<f64>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
}
impl<'a> Tickfont<'a> {
pub fn family(&mut self, family: &'a str) -> &mut Self {
self.family = Some(family);
self
}
pub fn size(&mut self, size: f64) -> &mut Self {
self.size = Some(size);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
}
pub enum Showtickprefix {
All,
First,
Last,
None,
}
impl serde::Serialize for Showtickprefix {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::All => serializer.serialize_str("all"),
Self::First => serializer.serialize_str("first"),
Self::Last => serializer.serialize_str("last"),
Self::None => serializer.serialize_str("none"),
}
}
}
pub enum Showticksuffix {
All,
First,
Last,
None,
}
impl serde::Serialize for Showticksuffix {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::All => serializer.serialize_str("all"),
Self::First => serializer.serialize_str("first"),
Self::Last => serializer.serialize_str("last"),
Self::None => serializer.serialize_str("none"),
}
}
}
pub enum Exponentformat {
None,
SmallE,
BigE,
Power,
Si,
B,
}
impl serde::Serialize for Exponentformat {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::None => serializer.serialize_str("none"),
Self::SmallE => serializer.serialize_str("e"),
Self::BigE => serializer.serialize_str("E"),
Self::Power => serializer.serialize_str("power"),
Self::Si => serializer.serialize_str("SI"),
Self::B => serializer.serialize_str("B"),
}
}
}
pub enum Showexponent {
All,
First,
Last,
None,
}
impl serde::Serialize for Showexponent {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::All => serializer.serialize_str("all"),
Self::First => serializer.serialize_str("first"),
Self::Last => serializer.serialize_str("last"),
Self::None => serializer.serialize_str("none"),
}
}
}
#[derive(Default, Serialize)]
pub struct Title<'a> {
#[serde(rename = "text")]
#[serde(skip_serializing_if = "Option::is_none")]
text: Option<&'a str>,
#[serde(rename = "font")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
font: crate::IsEmpty<title::Font<'a>>,
#[serde(rename = "side")]
#[serde(skip_serializing_if = "Option::is_none")]
side: Option<title::Side>,
}
impl<'a> Title<'a> {
pub fn text(&mut self, text: &'a str) -> &mut Self {
self.text = Some(text);
self
}
pub fn font(&mut self) -> &mut title::Font<'a> {
self.font.is_empty = false;
&mut self.font.data
}
pub fn side(&mut self, side: title::Side) -> &mut Self {
self.side = Some(side);
self
}
}
pub mod title {
#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Font<'a> {
#[serde(rename = "family")]
#[serde(skip_serializing_if = "Option::is_none")]
family: Option<&'a str>,
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<f64>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
}
impl<'a> Font<'a> {
pub fn family(&mut self, family: &'a str) -> &mut Self {
self.family = Some(family);
self
}
pub fn size(&mut self, size: f64) -> &mut Self {
self.size = Some(size);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
}
pub enum Side {
Right,
Top,
Bottom,
}
impl serde::Serialize for Side {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Right => serializer.serialize_str("right"),
Self::Top => serializer.serialize_str("top"),
Self::Bottom => serializer.serialize_str("bottom"),
}
}
}
}
}
#[derive(Default, Serialize)]
pub struct Contour<'a> {
#[serde(rename = "show")]
#[serde(skip_serializing_if = "Option::is_none")]
show: Option<bool>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
#[serde(rename = "width")]
#[serde(skip_serializing_if = "Option::is_none")]
width: Option<f64>,
}
impl<'a> Contour<'a> {
pub fn show(&mut self, show: bool) -> &mut Self {
self.show = Some(show);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
pub fn width(&mut self, width: f64) -> &mut Self {
self.width = Some(width);
self
}
}
#[derive(Default, Serialize)]
pub struct Lightposition<> {
#[serde(rename = "x")]
#[serde(skip_serializing_if = "Option::is_none")]
x: Option<f64>,
#[serde(rename = "y")]
#[serde(skip_serializing_if = "Option::is_none")]
y: Option<f64>,
#[serde(rename = "z")]
#[serde(skip_serializing_if = "Option::is_none")]
z: Option<f64>,
}
impl<> Lightposition<> {
pub fn x(&mut self, x: f64) -> &mut Self {
self.x = Some(x);
self
}
pub fn y(&mut self, y: f64) -> &mut Self {
self.y = Some(y);
self
}
pub fn z(&mut self, z: f64) -> &mut Self {
self.z = Some(z);
self
}
}
#[derive(Default, Serialize)]
pub struct Lighting<> {
#[serde(rename = "vertexnormalsepsilon")]
#[serde(skip_serializing_if = "Option::is_none")]
vertexnormalsepsilon: Option<f64>,
#[serde(rename = "facenormalsepsilon")]
#[serde(skip_serializing_if = "Option::is_none")]
facenormalsepsilon: Option<f64>,
#[serde(rename = "ambient")]
#[serde(skip_serializing_if = "Option::is_none")]
ambient: Option<f64>,
#[serde(rename = "diffuse")]
#[serde(skip_serializing_if = "Option::is_none")]
diffuse: Option<f64>,
#[serde(rename = "specular")]
#[serde(skip_serializing_if = "Option::is_none")]
specular: Option<f64>,
#[serde(rename = "roughness")]
#[serde(skip_serializing_if = "Option::is_none")]
roughness: Option<f64>,
#[serde(rename = "fresnel")]
#[serde(skip_serializing_if = "Option::is_none")]
fresnel: Option<f64>,
}
impl<> Lighting<> {
pub fn vertexnormalsepsilon(&mut self, vertexnormalsepsilon: f64) -> &mut Self {
self.vertexnormalsepsilon = Some(vertexnormalsepsilon);
self
}
pub fn facenormalsepsilon(&mut self, facenormalsepsilon: f64) -> &mut Self {
self.facenormalsepsilon = Some(facenormalsepsilon);
self
}
pub fn ambient(&mut self, ambient: f64) -> &mut Self {
self.ambient = Some(ambient);
self
}
pub fn diffuse(&mut self, diffuse: f64) -> &mut Self {
self.diffuse = Some(diffuse);
self
}
pub fn specular(&mut self, specular: f64) -> &mut Self {
self.specular = Some(specular);
self
}
pub fn roughness(&mut self, roughness: f64) -> &mut Self {
self.roughness = Some(roughness);
self
}
pub fn fresnel(&mut self, fresnel: f64) -> &mut Self {
self.fresnel = Some(fresnel);
self
}
}
#[derive(Default)]
pub struct HoverinfoFlags ([u8; 1]);
impl HoverinfoFlags {
pub fn x(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 0; }
else { self.0[0] &= !(1 << 0); }
self
}
pub fn y(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 1; }
else { self.0[0] &= !(1 << 1); }
self
}
pub fn z(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 2; }
else { self.0[0] &= !(1 << 2); }
self
}
pub fn text(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 3; }
else { self.0[0] &= !(1 << 3); }
self
}
pub fn name(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 4; }
else { self.0[0] &= !(1 << 4); }
self
}
}
impl serde::Serialize for HoverinfoFlags {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
#[allow(unused_mut)]
let mut v: Vec<&str> = Vec::new();
if (self.0[0] >> 0) & 0x1 == 1 {
v.push("x");
}
if (self.0[0] >> 1) & 0x1 == 1 {
v.push("y");
}
if (self.0[0] >> 2) & 0x1 == 1 {
v.push("z");
}
if (self.0[0] >> 3) & 0x1 == 1 {
v.push("text");
}
if (self.0[0] >> 4) & 0x1 == 1 {
v.push("name");
}
serializer.serialize_str(&v.join("+"))
}
}
pub enum Hoverinfo {
Flags(HoverinfoFlags),
All,
None,
Skip,
}
impl serde::Serialize for Hoverinfo {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::All => serializer.serialize_str("all"),
Self::None => serializer.serialize_str("none"),
Self::Skip => serializer.serialize_str("skip"),
Self::Flags(v) => v.serialize(serializer),
}
}
}
impl Default for Hoverinfo {
fn default() -> Self {
Self::Flags(HoverinfoFlags::default())
}
}
impl Hoverinfo {
pub fn flags(&mut self) -> &mut HoverinfoFlags {
*self = Self::Flags(HoverinfoFlags::default());
match self {
Self::Flags(v) => v,
_ => unreachable!(),
}
}
pub fn set(&mut self, v: Hoverinfo) {
*self = v;
}
}
pub enum Xcalendar {
Gregorian,
Chinese,
Coptic,
Discworld,
Ethiopian,
Hebrew,
Islamic,
Julian,
Mayan,
Nanakshahi,
Nepali,
Persian,
Jalali,
Taiwan,
Thai,
Ummalqura,
}
impl serde::Serialize for Xcalendar {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Gregorian => serializer.serialize_str("gregorian"),
Self::Chinese => serializer.serialize_str("chinese"),
Self::Coptic => serializer.serialize_str("coptic"),
Self::Discworld => serializer.serialize_str("discworld"),
Self::Ethiopian => serializer.serialize_str("ethiopian"),
Self::Hebrew => serializer.serialize_str("hebrew"),
Self::Islamic => serializer.serialize_str("islamic"),
Self::Julian => serializer.serialize_str("julian"),
Self::Mayan => serializer.serialize_str("mayan"),
Self::Nanakshahi => serializer.serialize_str("nanakshahi"),
Self::Nepali => serializer.serialize_str("nepali"),
Self::Persian => serializer.serialize_str("persian"),
Self::Jalali => serializer.serialize_str("jalali"),
Self::Taiwan => serializer.serialize_str("taiwan"),
Self::Thai => serializer.serialize_str("thai"),
Self::Ummalqura => serializer.serialize_str("ummalqura"),
}
}
}
pub enum Ycalendar {
Gregorian,
Chinese,
Coptic,
Discworld,
Ethiopian,
Hebrew,
Islamic,
Julian,
Mayan,
Nanakshahi,
Nepali,
Persian,
Jalali,
Taiwan,
Thai,
Ummalqura,
}
impl serde::Serialize for Ycalendar {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Gregorian => serializer.serialize_str("gregorian"),
Self::Chinese => serializer.serialize_str("chinese"),
Self::Coptic => serializer.serialize_str("coptic"),
Self::Discworld => serializer.serialize_str("discworld"),
Self::Ethiopian => serializer.serialize_str("ethiopian"),
Self::Hebrew => serializer.serialize_str("hebrew"),
Self::Islamic => serializer.serialize_str("islamic"),
Self::Julian => serializer.serialize_str("julian"),
Self::Mayan => serializer.serialize_str("mayan"),
Self::Nanakshahi => serializer.serialize_str("nanakshahi"),
Self::Nepali => serializer.serialize_str("nepali"),
Self::Persian => serializer.serialize_str("persian"),
Self::Jalali => serializer.serialize_str("jalali"),
Self::Taiwan => serializer.serialize_str("taiwan"),
Self::Thai => serializer.serialize_str("thai"),
Self::Ummalqura => serializer.serialize_str("ummalqura"),
}
}
}
pub enum Zcalendar {
Gregorian,
Chinese,
Coptic,
Discworld,
Ethiopian,
Hebrew,
Islamic,
Julian,
Mayan,
Nanakshahi,
Nepali,
Persian,
Jalali,
Taiwan,
Thai,
Ummalqura,
}
impl serde::Serialize for Zcalendar {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Gregorian => serializer.serialize_str("gregorian"),
Self::Chinese => serializer.serialize_str("chinese"),
Self::Coptic => serializer.serialize_str("coptic"),
Self::Discworld => serializer.serialize_str("discworld"),
Self::Ethiopian => serializer.serialize_str("ethiopian"),
Self::Hebrew => serializer.serialize_str("hebrew"),
Self::Islamic => serializer.serialize_str("islamic"),
Self::Julian => serializer.serialize_str("julian"),
Self::Mayan => serializer.serialize_str("mayan"),
Self::Nanakshahi => serializer.serialize_str("nanakshahi"),
Self::Nepali => serializer.serialize_str("nepali"),
Self::Persian => serializer.serialize_str("persian"),
Self::Jalali => serializer.serialize_str("jalali"),
Self::Taiwan => serializer.serialize_str("taiwan"),
Self::Thai => serializer.serialize_str("thai"),
Self::Ummalqura => serializer.serialize_str("ummalqura"),
}
}
}