#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Histogram<'a> {
#[serde(rename = "visible")]
#[serde(skip_serializing_if = "Option::is_none")]
visible: Option<Visible>,
#[serde(rename = "showlegend")]
#[serde(skip_serializing_if = "Option::is_none")]
showlegend: Option<bool>,
#[serde(rename = "legendgroup")]
#[serde(skip_serializing_if = "Option::is_none")]
legendgroup: Option<&'a str>,
#[serde(rename = "opacity")]
#[serde(skip_serializing_if = "Option::is_none")]
opacity: Option<f64>,
#[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 = "selectedpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
selectedpoints: Option<crate::Any>,
#[serde(rename = "hoverinfo")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
hoverinfo: crate::IsEmpty<Hoverinfo>,
#[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 = "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 = "orientation")]
#[serde(skip_serializing_if = "Option::is_none")]
orientation: Option<Orientation>,
#[serde(rename = "histfunc")]
#[serde(skip_serializing_if = "Option::is_none")]
histfunc: Option<Histfunc>,
#[serde(rename = "histnorm")]
#[serde(skip_serializing_if = "Option::is_none")]
histnorm: Option<Histnorm>,
#[serde(rename = "cumulative")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
cumulative: crate::IsEmpty<Cumulative<>>,
#[serde(rename = "nbinsx")]
#[serde(skip_serializing_if = "Option::is_none")]
nbinsx: Option<u64>,
#[serde(rename = "xbins")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
xbins: crate::IsEmpty<Xbins<>>,
#[serde(rename = "nbinsy")]
#[serde(skip_serializing_if = "Option::is_none")]
nbinsy: Option<u64>,
#[serde(rename = "ybins")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
ybins: crate::IsEmpty<Ybins<>>,
#[serde(rename = "autobinx")]
#[serde(skip_serializing_if = "Option::is_none")]
autobinx: Option<bool>,
#[serde(rename = "autobiny")]
#[serde(skip_serializing_if = "Option::is_none")]
autobiny: Option<bool>,
#[serde(rename = "bingroup")]
#[serde(skip_serializing_if = "Option::is_none")]
bingroup: Option<&'a str>,
#[serde(rename = "hovertemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertemplate: Option<&'a str>,
#[serde(rename = "marker")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
marker: crate::IsEmpty<Marker<'a>>,
#[serde(rename = "offsetgroup")]
#[serde(skip_serializing_if = "Option::is_none")]
offsetgroup: Option<&'a str>,
#[serde(rename = "alignmentgroup")]
#[serde(skip_serializing_if = "Option::is_none")]
alignmentgroup: Option<&'a str>,
#[serde(rename = "selected")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
selected: crate::IsEmpty<Selected<'a>>,
#[serde(rename = "unselected")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
unselected: crate::IsEmpty<Unselected<'a>>,
#[serde(rename = "error_x")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
error_x: crate::IsEmpty<ErrorX<'a>>,
#[serde(rename = "error_y")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
error_y: crate::IsEmpty<ErrorY<'a>>,
#[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 = "xaxis")]
#[serde(skip_serializing_if = "Option::is_none")]
xaxis: Option<&'a str>,
#[serde(rename = "yaxis")]
#[serde(skip_serializing_if = "Option::is_none")]
yaxis: 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 = "hoverinfosrc")]
#[serde(skip_serializing_if = "Option::is_none")]
hoverinfosrc: 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 = "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>,
}
impl<'a> Histogram<'a> {
pub fn visible(&mut self, visible: Visible) -> &mut Self {
self.visible = Some(visible);
self
}
pub fn showlegend(&mut self, showlegend: bool) -> &mut Self {
self.showlegend = Some(showlegend);
self
}
pub fn legendgroup(&mut self, legendgroup: &'a str) -> &mut Self {
self.legendgroup = Some(legendgroup);
self
}
pub fn opacity(&mut self, opacity: f64) -> &mut Self {
self.opacity = Some(opacity);
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 selectedpoints(&mut self, selectedpoints: crate::Any) -> &mut Self {
self.selectedpoints = Some(selectedpoints);
self
}
pub fn hoverinfo(&mut self) -> &mut Hoverinfo {
self.hoverinfo.is_empty = false;
&mut self.hoverinfo.data
}
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 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 orientation(&mut self, orientation: Orientation) -> &mut Self {
self.orientation = Some(orientation);
self
}
pub fn histfunc(&mut self, histfunc: Histfunc) -> &mut Self {
self.histfunc = Some(histfunc);
self
}
pub fn histnorm(&mut self, histnorm: Histnorm) -> &mut Self {
self.histnorm = Some(histnorm);
self
}
pub fn cumulative(&mut self) -> &mut Cumulative<> {
self.cumulative.is_empty = false;
&mut self.cumulative.data
}
pub fn nbinsx(&mut self, nbinsx: u64) -> &mut Self {
self.nbinsx = Some(nbinsx);
self
}
pub fn xbins(&mut self) -> &mut Xbins<> {
self.xbins.is_empty = false;
&mut self.xbins.data
}
pub fn nbinsy(&mut self, nbinsy: u64) -> &mut Self {
self.nbinsy = Some(nbinsy);
self
}
pub fn ybins(&mut self) -> &mut Ybins<> {
self.ybins.is_empty = false;
&mut self.ybins.data
}
pub fn autobinx(&mut self, autobinx: bool) -> &mut Self {
self.autobinx = Some(autobinx);
self
}
pub fn autobiny(&mut self, autobiny: bool) -> &mut Self {
self.autobiny = Some(autobiny);
self
}
pub fn bingroup(&mut self, bingroup: &'a str) -> &mut Self {
self.bingroup = Some(bingroup);
self
}
pub fn hovertemplate(&mut self, hovertemplate: &'a str) -> &mut Self {
self.hovertemplate = Some(hovertemplate);
self
}
pub fn marker(&mut self) -> &mut Marker<'a> {
self.marker.is_empty = false;
&mut self.marker.data
}
pub fn offsetgroup(&mut self, offsetgroup: &'a str) -> &mut Self {
self.offsetgroup = Some(offsetgroup);
self
}
pub fn alignmentgroup(&mut self, alignmentgroup: &'a str) -> &mut Self {
self.alignmentgroup = Some(alignmentgroup);
self
}
pub fn selected(&mut self) -> &mut Selected<'a> {
self.selected.is_empty = false;
&mut self.selected.data
}
pub fn unselected(&mut self) -> &mut Unselected<'a> {
self.unselected.is_empty = false;
&mut self.unselected.data
}
pub fn error_x(&mut self) -> &mut ErrorX<'a> {
self.error_x.is_empty = false;
&mut self.error_x.data
}
pub fn error_y(&mut self) -> &mut ErrorY<'a> {
self.error_y.is_empty = false;
&mut self.error_y.data
}
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 xaxis(&mut self, xaxis: &'a str) -> &mut Self {
self.xaxis = Some(xaxis);
self
}
pub fn yaxis(&mut self, yaxis: &'a str) -> &mut Self {
self.yaxis = Some(yaxis);
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 hoverinfosrc(&mut self, hoverinfosrc: &'a str) -> &mut Self {
self.hoverinfosrc = Some(hoverinfosrc);
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 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 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)]
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;
}
}
#[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 Orientation {
V,
H,
}
impl serde::Serialize for Orientation {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::V => serializer.serialize_str("v"),
Self::H => serializer.serialize_str("h"),
}
}
}
pub enum Histfunc {
Count,
Sum,
Avg,
Min,
Max,
}
impl serde::Serialize for Histfunc {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Count => serializer.serialize_str("count"),
Self::Sum => serializer.serialize_str("sum"),
Self::Avg => serializer.serialize_str("avg"),
Self::Min => serializer.serialize_str("min"),
Self::Max => serializer.serialize_str("max"),
}
}
}
pub enum Histnorm {
Percent,
Probability,
Density,
ProbabilityDensity,
}
impl serde::Serialize for Histnorm {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Percent => serializer.serialize_str("percent"),
Self::Probability => serializer.serialize_str("probability"),
Self::Density => serializer.serialize_str("density"),
Self::ProbabilityDensity => serializer.serialize_str("probability density"),
}
}
}
#[derive(Default, Serialize)]
pub struct Cumulative<> {
#[serde(rename = "enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
enabled: Option<bool>,
#[serde(rename = "direction")]
#[serde(skip_serializing_if = "Option::is_none")]
direction: Option<cumulative::Direction>,
#[serde(rename = "currentbin")]
#[serde(skip_serializing_if = "Option::is_none")]
currentbin: Option<cumulative::Currentbin>,
}
impl<> Cumulative<> {
pub fn enabled(&mut self, enabled: bool) -> &mut Self {
self.enabled = Some(enabled);
self
}
pub fn direction(&mut self, direction: cumulative::Direction) -> &mut Self {
self.direction = Some(direction);
self
}
pub fn currentbin(&mut self, currentbin: cumulative::Currentbin) -> &mut Self {
self.currentbin = Some(currentbin);
self
}
}
pub mod cumulative {
#[allow(unused_imports)]
use serde::Serialize;
pub enum Direction {
Increasing,
Decreasing,
}
impl serde::Serialize for Direction {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Increasing => serializer.serialize_str("increasing"),
Self::Decreasing => serializer.serialize_str("decreasing"),
}
}
}
pub enum Currentbin {
Include,
Exclude,
Half,
}
impl serde::Serialize for Currentbin {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Include => serializer.serialize_str("include"),
Self::Exclude => serializer.serialize_str("exclude"),
Self::Half => serializer.serialize_str("half"),
}
}
}
}
#[derive(Default, Serialize)]
pub struct Xbins<> {
#[serde(rename = "start")]
#[serde(skip_serializing_if = "Option::is_none")]
start: Option<crate::Any>,
#[serde(rename = "end")]
#[serde(skip_serializing_if = "Option::is_none")]
end: Option<crate::Any>,
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<crate::Any>,
}
impl<> Xbins<> {
pub fn start(&mut self, start: crate::Any) -> &mut Self {
self.start = Some(start);
self
}
pub fn end(&mut self, end: crate::Any) -> &mut Self {
self.end = Some(end);
self
}
pub fn size(&mut self, size: crate::Any) -> &mut Self {
self.size = Some(size);
self
}
}
#[derive(Default, Serialize)]
pub struct Ybins<> {
#[serde(rename = "start")]
#[serde(skip_serializing_if = "Option::is_none")]
start: Option<crate::Any>,
#[serde(rename = "end")]
#[serde(skip_serializing_if = "Option::is_none")]
end: Option<crate::Any>,
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<crate::Any>,
}
impl<> Ybins<> {
pub fn start(&mut self, start: crate::Any) -> &mut Self {
self.start = Some(start);
self
}
pub fn end(&mut self, end: crate::Any) -> &mut Self {
self.end = Some(end);
self
}
pub fn size(&mut self, size: crate::Any) -> &mut Self {
self.size = Some(size);
self
}
}
#[derive(Default, Serialize)]
pub struct Marker<'a> {
#[serde(rename = "line")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
line: crate::IsEmpty<marker::Line<'a>>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
#[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<marker::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>,
}
impl<'a> Marker<'a> {
pub fn line(&mut self) -> &mut marker::Line<'a> {
self.line.is_empty = false;
&mut self.line.data
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
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 marker::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 mod marker {
#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Line<'a> {
#[serde(rename = "width")]
#[serde(skip_serializing_if = "Option::is_none")]
width: Option<f64>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
#[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 = "coloraxis")]
#[serde(skip_serializing_if = "Option::is_none")]
coloraxis: Option<&'a str>,
}
impl<'a> Line<'a> {
pub fn width(&mut self, width: f64) -> &mut Self {
self.width = Some(width);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
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 coloraxis(&mut self, coloraxis: &'a str) -> &mut Self {
self.coloraxis = Some(coloraxis);
self
}
}
#[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 Selected<'a> {
#[serde(rename = "marker")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
marker: crate::IsEmpty<selected::Marker<'a>>,
#[serde(rename = "textfont")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
textfont: crate::IsEmpty<selected::Textfont<'a>>,
}
impl<'a> Selected<'a> {
pub fn marker(&mut self) -> &mut selected::Marker<'a> {
self.marker.is_empty = false;
&mut self.marker.data
}
pub fn textfont(&mut self) -> &mut selected::Textfont<'a> {
self.textfont.is_empty = false;
&mut self.textfont.data
}
}
pub mod selected {
#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Marker<'a> {
#[serde(rename = "opacity")]
#[serde(skip_serializing_if = "Option::is_none")]
opacity: Option<f64>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
}
impl<'a> Marker<'a> {
pub fn opacity(&mut self, opacity: f64) -> &mut Self {
self.opacity = Some(opacity);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
}
#[derive(Default, Serialize)]
pub struct Textfont<'a> {
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
}
impl<'a> Textfont<'a> {
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
}
}
#[derive(Default, Serialize)]
pub struct Unselected<'a> {
#[serde(rename = "marker")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
marker: crate::IsEmpty<unselected::Marker<'a>>,
#[serde(rename = "textfont")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
textfont: crate::IsEmpty<unselected::Textfont<'a>>,
}
impl<'a> Unselected<'a> {
pub fn marker(&mut self) -> &mut unselected::Marker<'a> {
self.marker.is_empty = false;
&mut self.marker.data
}
pub fn textfont(&mut self) -> &mut unselected::Textfont<'a> {
self.textfont.is_empty = false;
&mut self.textfont.data
}
}
pub mod unselected {
#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Marker<'a> {
#[serde(rename = "opacity")]
#[serde(skip_serializing_if = "Option::is_none")]
opacity: Option<f64>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
}
impl<'a> Marker<'a> {
pub fn opacity(&mut self, opacity: f64) -> &mut Self {
self.opacity = Some(opacity);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
}
#[derive(Default, Serialize)]
pub struct Textfont<'a> {
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
}
impl<'a> Textfont<'a> {
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
}
}
#[derive(Default, Serialize)]
pub struct ErrorX<'a> {
#[serde(rename = "visible")]
#[serde(skip_serializing_if = "Option::is_none")]
visible: Option<bool>,
#[serde(rename = "symmetric")]
#[serde(skip_serializing_if = "Option::is_none")]
symmetric: Option<bool>,
#[serde(rename = "array")]
#[serde(skip_serializing_if = "Option::is_none")]
array: Option<&'a [f64]>,
#[serde(rename = "arrayminus")]
#[serde(skip_serializing_if = "Option::is_none")]
arrayminus: Option<&'a [f64]>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
value: Option<f64>,
#[serde(rename = "valueminus")]
#[serde(skip_serializing_if = "Option::is_none")]
valueminus: Option<f64>,
#[serde(rename = "traceref")]
#[serde(skip_serializing_if = "Option::is_none")]
traceref: Option<u64>,
#[serde(rename = "tracerefminus")]
#[serde(skip_serializing_if = "Option::is_none")]
tracerefminus: Option<u64>,
#[serde(rename = "copy_ystyle")]
#[serde(skip_serializing_if = "Option::is_none")]
copy_ystyle: Option<bool>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
#[serde(rename = "thickness")]
#[serde(skip_serializing_if = "Option::is_none")]
thickness: Option<f64>,
#[serde(rename = "width")]
#[serde(skip_serializing_if = "Option::is_none")]
width: Option<f64>,
}
impl<'a> ErrorX<'a> {
pub fn visible(&mut self, visible: bool) -> &mut Self {
self.visible = Some(visible);
self
}
pub fn symmetric(&mut self, symmetric: bool) -> &mut Self {
self.symmetric = Some(symmetric);
self
}
pub fn array(&mut self, array: &'a [f64]) -> &mut Self {
self.array = Some(array);
self
}
pub fn arrayminus(&mut self, arrayminus: &'a [f64]) -> &mut Self {
self.arrayminus = Some(arrayminus);
self
}
pub fn value(&mut self, value: f64) -> &mut Self {
self.value = Some(value);
self
}
pub fn valueminus(&mut self, valueminus: f64) -> &mut Self {
self.valueminus = Some(valueminus);
self
}
pub fn traceref(&mut self, traceref: u64) -> &mut Self {
self.traceref = Some(traceref);
self
}
pub fn tracerefminus(&mut self, tracerefminus: u64) -> &mut Self {
self.tracerefminus = Some(tracerefminus);
self
}
pub fn copy_ystyle(&mut self, copy_ystyle: bool) -> &mut Self {
self.copy_ystyle = Some(copy_ystyle);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
pub fn thickness(&mut self, thickness: f64) -> &mut Self {
self.thickness = Some(thickness);
self
}
pub fn width(&mut self, width: f64) -> &mut Self {
self.width = Some(width);
self
}
}
#[derive(Default, Serialize)]
pub struct ErrorY<'a> {
#[serde(rename = "visible")]
#[serde(skip_serializing_if = "Option::is_none")]
visible: Option<bool>,
#[serde(rename = "symmetric")]
#[serde(skip_serializing_if = "Option::is_none")]
symmetric: Option<bool>,
#[serde(rename = "array")]
#[serde(skip_serializing_if = "Option::is_none")]
array: Option<&'a [f64]>,
#[serde(rename = "arrayminus")]
#[serde(skip_serializing_if = "Option::is_none")]
arrayminus: Option<&'a [f64]>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
value: Option<f64>,
#[serde(rename = "valueminus")]
#[serde(skip_serializing_if = "Option::is_none")]
valueminus: Option<f64>,
#[serde(rename = "traceref")]
#[serde(skip_serializing_if = "Option::is_none")]
traceref: Option<u64>,
#[serde(rename = "tracerefminus")]
#[serde(skip_serializing_if = "Option::is_none")]
tracerefminus: Option<u64>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
#[serde(rename = "thickness")]
#[serde(skip_serializing_if = "Option::is_none")]
thickness: Option<f64>,
#[serde(rename = "width")]
#[serde(skip_serializing_if = "Option::is_none")]
width: Option<f64>,
}
impl<'a> ErrorY<'a> {
pub fn visible(&mut self, visible: bool) -> &mut Self {
self.visible = Some(visible);
self
}
pub fn symmetric(&mut self, symmetric: bool) -> &mut Self {
self.symmetric = Some(symmetric);
self
}
pub fn array(&mut self, array: &'a [f64]) -> &mut Self {
self.array = Some(array);
self
}
pub fn arrayminus(&mut self, arrayminus: &'a [f64]) -> &mut Self {
self.arrayminus = Some(arrayminus);
self
}
pub fn value(&mut self, value: f64) -> &mut Self {
self.value = Some(value);
self
}
pub fn valueminus(&mut self, valueminus: f64) -> &mut Self {
self.valueminus = Some(valueminus);
self
}
pub fn traceref(&mut self, traceref: u64) -> &mut Self {
self.traceref = Some(traceref);
self
}
pub fn tracerefminus(&mut self, tracerefminus: u64) -> &mut Self {
self.tracerefminus = Some(tracerefminus);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
pub fn thickness(&mut self, thickness: f64) -> &mut Self {
self.thickness = Some(thickness);
self
}
pub fn width(&mut self, width: f64) -> &mut Self {
self.width = Some(width);
self
}
}
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"),
}
}
}