#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Scattergeo<'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 = "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 = "lon")]
#[serde(skip_serializing_if = "Option::is_none")]
lon: Option<&'a [f64]>,
#[serde(rename = "lat")]
#[serde(skip_serializing_if = "Option::is_none")]
lat: Option<&'a [f64]>,
#[serde(rename = "locations")]
#[serde(skip_serializing_if = "Option::is_none")]
locations: Option<&'a [f64]>,
#[serde(rename = "locationmode")]
#[serde(skip_serializing_if = "Option::is_none")]
locationmode: Option<Locationmode>,
#[serde(rename = "geojson")]
#[serde(skip_serializing_if = "Option::is_none")]
geojson: Option<crate::Any>,
#[serde(rename = "featureidkey")]
#[serde(skip_serializing_if = "Option::is_none")]
featureidkey: Option<&'a str>,
#[serde(rename = "mode")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
mode: crate::IsEmpty<Mode>,
#[serde(rename = "text")]
#[serde(skip_serializing_if = "Option::is_none")]
text: Option<&'a str>,
#[serde(rename = "texttemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
texttemplate: Option<&'a str>,
#[serde(rename = "hovertext")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertext: Option<&'a str>,
#[serde(rename = "textfont")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
textfont: crate::IsEmpty<Textfont<'a>>,
#[serde(rename = "textposition")]
#[serde(skip_serializing_if = "Option::is_none")]
textposition: Option<Textposition>,
#[serde(rename = "line")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
line: crate::IsEmpty<Line<'a>>,
#[serde(rename = "connectgaps")]
#[serde(skip_serializing_if = "Option::is_none")]
connectgaps: Option<bool>,
#[serde(rename = "marker")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
marker: crate::IsEmpty<Marker<'a>>,
#[serde(rename = "fill")]
#[serde(skip_serializing_if = "Option::is_none")]
fill: Option<Fill>,
#[serde(rename = "fillcolor")]
#[serde(skip_serializing_if = "Option::is_none")]
fillcolor: 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 = "hoverinfo")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
hoverinfo: crate::IsEmpty<Hoverinfo>,
#[serde(rename = "hovertemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertemplate: Option<&'a str>,
#[serde(rename = "geo")]
#[serde(skip_serializing_if = "Option::is_none")]
geo: 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 = "lonsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
lonsrc: Option<&'a str>,
#[serde(rename = "latsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
latsrc: Option<&'a str>,
#[serde(rename = "locationssrc")]
#[serde(skip_serializing_if = "Option::is_none")]
locationssrc: Option<&'a str>,
#[serde(rename = "textsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
textsrc: Option<&'a str>,
#[serde(rename = "texttemplatesrc")]
#[serde(skip_serializing_if = "Option::is_none")]
texttemplatesrc: Option<&'a str>,
#[serde(rename = "hovertextsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertextsrc: Option<&'a str>,
#[serde(rename = "textpositionsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
textpositionsrc: Option<&'a str>,
#[serde(rename = "hoverinfosrc")]
#[serde(skip_serializing_if = "Option::is_none")]
hoverinfosrc: Option<&'a str>,
#[serde(rename = "hovertemplatesrc")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertemplatesrc: Option<&'a str>,
}
impl<'a> Scattergeo<'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 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 lon(&mut self, lon: &'a [f64]) -> &mut Self {
self.lon = Some(lon);
self
}
pub fn lat(&mut self, lat: &'a [f64]) -> &mut Self {
self.lat = Some(lat);
self
}
pub fn locations(&mut self, locations: &'a [f64]) -> &mut Self {
self.locations = Some(locations);
self
}
pub fn locationmode(&mut self, locationmode: Locationmode) -> &mut Self {
self.locationmode = Some(locationmode);
self
}
pub fn geojson(&mut self, geojson: crate::Any) -> &mut Self {
self.geojson = Some(geojson);
self
}
pub fn featureidkey(&mut self, featureidkey: &'a str) -> &mut Self {
self.featureidkey = Some(featureidkey);
self
}
pub fn mode(&mut self) -> &mut Mode {
self.mode.is_empty = false;
&mut self.mode.data
}
pub fn text(&mut self, text: &'a str) -> &mut Self {
self.text = Some(text);
self
}
pub fn texttemplate(&mut self, texttemplate: &'a str) -> &mut Self {
self.texttemplate = Some(texttemplate);
self
}
pub fn hovertext(&mut self, hovertext: &'a str) -> &mut Self {
self.hovertext = Some(hovertext);
self
}
pub fn textfont(&mut self) -> &mut Textfont<'a> {
self.textfont.is_empty = false;
&mut self.textfont.data
}
pub fn textposition(&mut self, textposition: Textposition) -> &mut Self {
self.textposition = Some(textposition);
self
}
pub fn line(&mut self) -> &mut Line<'a> {
self.line.is_empty = false;
&mut self.line.data
}
pub fn connectgaps(&mut self, connectgaps: bool) -> &mut Self {
self.connectgaps = Some(connectgaps);
self
}
pub fn marker(&mut self) -> &mut Marker<'a> {
self.marker.is_empty = false;
&mut self.marker.data
}
pub fn fill(&mut self, fill: Fill) -> &mut Self {
self.fill = Some(fill);
self
}
pub fn fillcolor(&mut self, fillcolor: &'a str) -> &mut Self {
self.fillcolor = Some(fillcolor);
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 hoverinfo(&mut self) -> &mut Hoverinfo {
self.hoverinfo.is_empty = false;
&mut self.hoverinfo.data
}
pub fn hovertemplate(&mut self, hovertemplate: &'a str) -> &mut Self {
self.hovertemplate = Some(hovertemplate);
self
}
pub fn geo(&mut self, geo: &'a str) -> &mut Self {
self.geo = Some(geo);
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 lonsrc(&mut self, lonsrc: &'a str) -> &mut Self {
self.lonsrc = Some(lonsrc);
self
}
pub fn latsrc(&mut self, latsrc: &'a str) -> &mut Self {
self.latsrc = Some(latsrc);
self
}
pub fn locationssrc(&mut self, locationssrc: &'a str) -> &mut Self {
self.locationssrc = Some(locationssrc);
self
}
pub fn textsrc(&mut self, textsrc: &'a str) -> &mut Self {
self.textsrc = Some(textsrc);
self
}
pub fn texttemplatesrc(&mut self, texttemplatesrc: &'a str) -> &mut Self {
self.texttemplatesrc = Some(texttemplatesrc);
self
}
pub fn hovertextsrc(&mut self, hovertextsrc: &'a str) -> &mut Self {
self.hovertextsrc = Some(hovertextsrc);
self
}
pub fn textpositionsrc(&mut self, textpositionsrc: &'a str) -> &mut Self {
self.textpositionsrc = Some(textpositionsrc);
self
}
pub fn hoverinfosrc(&mut self, hoverinfosrc: &'a str) -> &mut Self {
self.hoverinfosrc = Some(hoverinfosrc);
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, 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 Locationmode {
Iso3,
UsaStates,
CountryNames,
GeojsonId,
}
impl serde::Serialize for Locationmode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Iso3 => serializer.serialize_str("ISO-3"),
Self::UsaStates => serializer.serialize_str("USA-states"),
Self::CountryNames => serializer.serialize_str("country names"),
Self::GeojsonId => serializer.serialize_str("geojson-id"),
}
}
}
#[derive(Default)]
pub struct ModeFlags ([u8; 1]);
impl ModeFlags {
pub fn lines(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 0; }
else { self.0[0] &= !(1 << 0); }
self
}
pub fn markers(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 1; }
else { self.0[0] &= !(1 << 1); }
self
}
pub fn text(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 2; }
else { self.0[0] &= !(1 << 2); }
self
}
}
impl serde::Serialize for ModeFlags {
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("lines");
}
if (self.0[0] >> 1) & 0x1 == 1 {
v.push("markers");
}
if (self.0[0] >> 2) & 0x1 == 1 {
v.push("text");
}
serializer.serialize_str(&v.join("+"))
}
}
pub enum Mode {
Flags(ModeFlags),
None,
}
impl serde::Serialize for Mode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::None => serializer.serialize_str("none"),
Self::Flags(v) => v.serialize(serializer),
}
}
}
impl Default for Mode {
fn default() -> Self {
Self::Flags(ModeFlags::default())
}
}
impl Mode {
pub fn flags(&mut self) -> &mut ModeFlags {
*self = Self::Flags(ModeFlags::default());
match self {
Self::Flags(v) => v,
_ => unreachable!(),
}
}
pub fn set(&mut self, v: Mode) {
*self = v;
}
}
#[derive(Default, Serialize)]
pub struct Textfont<'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> Textfont<'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 Textposition {
TopLeft,
TopCenter,
TopRight,
MiddleLeft,
MiddleCenter,
MiddleRight,
BottomLeft,
BottomCenter,
BottomRight,
}
impl serde::Serialize for Textposition {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::TopLeft => serializer.serialize_str("top left"),
Self::TopCenter => serializer.serialize_str("top center"),
Self::TopRight => serializer.serialize_str("top right"),
Self::MiddleLeft => serializer.serialize_str("middle left"),
Self::MiddleCenter => serializer.serialize_str("middle center"),
Self::MiddleRight => serializer.serialize_str("middle right"),
Self::BottomLeft => serializer.serialize_str("bottom left"),
Self::BottomCenter => serializer.serialize_str("bottom center"),
Self::BottomRight => serializer.serialize_str("bottom right"),
}
}
}
#[derive(Default, Serialize)]
pub struct Line<'a> {
#[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>,
#[serde(rename = "dash")]
#[serde(skip_serializing_if = "Option::is_none")]
dash: Option<&'a str>,
}
impl<'a> Line<'a> {
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
}
pub fn dash(&mut self, dash: &'a str) -> &mut Self {
self.dash = Some(dash);
self
}
}
#[derive(Default, Serialize)]
pub struct Marker<'a> {
#[serde(rename = "symbol")]
#[serde(skip_serializing_if = "Option::is_none")]
symbol: Option<marker::Symbol>,
#[serde(rename = "opacity")]
#[serde(skip_serializing_if = "Option::is_none")]
opacity: Option<f64>,
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<f64>,
#[serde(rename = "sizeref")]
#[serde(skip_serializing_if = "Option::is_none")]
sizeref: Option<f64>,
#[serde(rename = "sizemin")]
#[serde(skip_serializing_if = "Option::is_none")]
sizemin: Option<f64>,
#[serde(rename = "sizemode")]
#[serde(skip_serializing_if = "Option::is_none")]
sizemode: Option<marker::Sizemode>,
#[serde(rename = "colorbar")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
colorbar: crate::IsEmpty<marker::Colorbar<'a>>,
#[serde(rename = "line")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
line: crate::IsEmpty<marker::Line<'a>>,
#[serde(rename = "gradient")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
gradient: crate::IsEmpty<marker::Gradient<'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 = "coloraxis")]
#[serde(skip_serializing_if = "Option::is_none")]
coloraxis: Option<&'a str>,
}
impl<'a> Marker<'a> {
pub fn symbol(&mut self, symbol: marker::Symbol) -> &mut Self {
self.symbol = Some(symbol);
self
}
pub fn opacity(&mut self, opacity: f64) -> &mut Self {
self.opacity = Some(opacity);
self
}
pub fn size(&mut self, size: f64) -> &mut Self {
self.size = Some(size);
self
}
pub fn sizeref(&mut self, sizeref: f64) -> &mut Self {
self.sizeref = Some(sizeref);
self
}
pub fn sizemin(&mut self, sizemin: f64) -> &mut Self {
self.sizemin = Some(sizemin);
self
}
pub fn sizemode(&mut self, sizemode: marker::Sizemode) -> &mut Self {
self.sizemode = Some(sizemode);
self
}
pub fn colorbar(&mut self) -> &mut marker::Colorbar<'a> {
self.colorbar.is_empty = false;
&mut self.colorbar.data
}
pub fn line(&mut self) -> &mut marker::Line<'a> {
self.line.is_empty = false;
&mut self.line.data
}
pub fn gradient(&mut self) -> &mut marker::Gradient<'a> {
self.gradient.is_empty = false;
&mut self.gradient.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 coloraxis(&mut self, coloraxis: &'a str) -> &mut Self {
self.coloraxis = Some(coloraxis);
self
}
}
pub mod marker {
#[allow(unused_imports)]
use serde::Serialize;
pub enum Symbol {
Num0,
Circle,
Num100,
CircleOpen,
Num200,
CircleDot,
Num300,
CircleOpenDot,
Num1,
Square,
Num101,
SquareOpen,
Num201,
SquareDot,
Num301,
SquareOpenDot,
Num2,
Diamond,
Num102,
DiamondOpen,
Num202,
DiamondDot,
Num302,
DiamondOpenDot,
Num3,
Cross,
Num103,
CrossOpen,
Num203,
CrossDot,
Num303,
CrossOpenDot,
Num4,
X,
Num104,
XOpen,
Num204,
XDot,
Num304,
XOpenDot,
Num5,
TriangleUp,
Num105,
TriangleUpOpen,
Num205,
TriangleUpDot,
Num305,
TriangleUpOpenDot,
Num6,
TriangleDown,
Num106,
TriangleDownOpen,
Num206,
TriangleDownDot,
Num306,
TriangleDownOpenDot,
Num7,
TriangleLeft,
Num107,
TriangleLeftOpen,
Num207,
TriangleLeftDot,
Num307,
TriangleLeftOpenDot,
Num8,
TriangleRight,
Num108,
TriangleRightOpen,
Num208,
TriangleRightDot,
Num308,
TriangleRightOpenDot,
Num9,
TriangleNe,
Num109,
TriangleNeOpen,
Num209,
TriangleNeDot,
Num309,
TriangleNeOpenDot,
Num10,
TriangleSe,
Num110,
TriangleSeOpen,
Num210,
TriangleSeDot,
Num310,
TriangleSeOpenDot,
Num11,
TriangleSw,
Num111,
TriangleSwOpen,
Num211,
TriangleSwDot,
Num311,
TriangleSwOpenDot,
Num12,
TriangleNw,
Num112,
TriangleNwOpen,
Num212,
TriangleNwDot,
Num312,
TriangleNwOpenDot,
Num13,
Pentagon,
Num113,
PentagonOpen,
Num213,
PentagonDot,
Num313,
PentagonOpenDot,
Num14,
Hexagon,
Num114,
HexagonOpen,
Num214,
HexagonDot,
Num314,
HexagonOpenDot,
Num15,
Hexagon2,
Num115,
Hexagon2Open,
Num215,
Hexagon2Dot,
Num315,
Hexagon2OpenDot,
Num16,
Octagon,
Num116,
OctagonOpen,
Num216,
OctagonDot,
Num316,
OctagonOpenDot,
Num17,
Star,
Num117,
StarOpen,
Num217,
StarDot,
Num317,
StarOpenDot,
Num18,
Hexagram,
Num118,
HexagramOpen,
Num218,
HexagramDot,
Num318,
HexagramOpenDot,
Num19,
StarTriangleUp,
Num119,
StarTriangleUpOpen,
Num219,
StarTriangleUpDot,
Num319,
StarTriangleUpOpenDot,
Num20,
StarTriangleDown,
Num120,
StarTriangleDownOpen,
Num220,
StarTriangleDownDot,
Num320,
StarTriangleDownOpenDot,
Num21,
StarSquare,
Num121,
StarSquareOpen,
Num221,
StarSquareDot,
Num321,
StarSquareOpenDot,
Num22,
StarDiamond,
Num122,
StarDiamondOpen,
Num222,
StarDiamondDot,
Num322,
StarDiamondOpenDot,
Num23,
DiamondTall,
Num123,
DiamondTallOpen,
Num223,
DiamondTallDot,
Num323,
DiamondTallOpenDot,
Num24,
DiamondWide,
Num124,
DiamondWideOpen,
Num224,
DiamondWideDot,
Num324,
DiamondWideOpenDot,
Num25,
Hourglass,
Num125,
HourglassOpen,
Num26,
Bowtie,
Num126,
BowtieOpen,
Num27,
CircleCross,
Num127,
CircleCrossOpen,
Num28,
CircleX,
Num128,
CircleXOpen,
Num29,
SquareCross,
Num129,
SquareCrossOpen,
Num30,
SquareX,
Num130,
SquareXOpen,
Num31,
DiamondCross,
Num131,
DiamondCrossOpen,
Num32,
DiamondX,
Num132,
DiamondXOpen,
Num33,
CrossThin,
Num133,
CrossThinOpen,
Num34,
XThin,
Num134,
XThinOpen,
Num35,
Asterisk,
Num135,
AsteriskOpen,
Num36,
Hash,
Num136,
HashOpen,
Num236,
HashDot,
Num336,
HashOpenDot,
Num37,
YUp,
Num137,
YUpOpen,
Num38,
YDown,
Num138,
YDownOpen,
Num39,
YLeft,
Num139,
YLeftOpen,
Num40,
YRight,
Num140,
YRightOpen,
Num41,
LineEw,
Num141,
LineEwOpen,
Num42,
LineNs,
Num142,
LineNsOpen,
Num43,
LineNe,
Num143,
LineNeOpen,
Num44,
LineNw,
Num144,
LineNwOpen,
}
impl serde::Serialize for Symbol {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Num0 => serializer.serialize_u64(0),
Self::Circle => serializer.serialize_str("circle"),
Self::Num100 => serializer.serialize_u64(100),
Self::CircleOpen => serializer.serialize_str("circle-open"),
Self::Num200 => serializer.serialize_u64(200),
Self::CircleDot => serializer.serialize_str("circle-dot"),
Self::Num300 => serializer.serialize_u64(300),
Self::CircleOpenDot => serializer.serialize_str("circle-open-dot"),
Self::Num1 => serializer.serialize_u64(1),
Self::Square => serializer.serialize_str("square"),
Self::Num101 => serializer.serialize_u64(101),
Self::SquareOpen => serializer.serialize_str("square-open"),
Self::Num201 => serializer.serialize_u64(201),
Self::SquareDot => serializer.serialize_str("square-dot"),
Self::Num301 => serializer.serialize_u64(301),
Self::SquareOpenDot => serializer.serialize_str("square-open-dot"),
Self::Num2 => serializer.serialize_u64(2),
Self::Diamond => serializer.serialize_str("diamond"),
Self::Num102 => serializer.serialize_u64(102),
Self::DiamondOpen => serializer.serialize_str("diamond-open"),
Self::Num202 => serializer.serialize_u64(202),
Self::DiamondDot => serializer.serialize_str("diamond-dot"),
Self::Num302 => serializer.serialize_u64(302),
Self::DiamondOpenDot => serializer.serialize_str("diamond-open-dot"),
Self::Num3 => serializer.serialize_u64(3),
Self::Cross => serializer.serialize_str("cross"),
Self::Num103 => serializer.serialize_u64(103),
Self::CrossOpen => serializer.serialize_str("cross-open"),
Self::Num203 => serializer.serialize_u64(203),
Self::CrossDot => serializer.serialize_str("cross-dot"),
Self::Num303 => serializer.serialize_u64(303),
Self::CrossOpenDot => serializer.serialize_str("cross-open-dot"),
Self::Num4 => serializer.serialize_u64(4),
Self::X => serializer.serialize_str("x"),
Self::Num104 => serializer.serialize_u64(104),
Self::XOpen => serializer.serialize_str("x-open"),
Self::Num204 => serializer.serialize_u64(204),
Self::XDot => serializer.serialize_str("x-dot"),
Self::Num304 => serializer.serialize_u64(304),
Self::XOpenDot => serializer.serialize_str("x-open-dot"),
Self::Num5 => serializer.serialize_u64(5),
Self::TriangleUp => serializer.serialize_str("triangle-up"),
Self::Num105 => serializer.serialize_u64(105),
Self::TriangleUpOpen => serializer.serialize_str("triangle-up-open"),
Self::Num205 => serializer.serialize_u64(205),
Self::TriangleUpDot => serializer.serialize_str("triangle-up-dot"),
Self::Num305 => serializer.serialize_u64(305),
Self::TriangleUpOpenDot => serializer.serialize_str("triangle-up-open-dot"),
Self::Num6 => serializer.serialize_u64(6),
Self::TriangleDown => serializer.serialize_str("triangle-down"),
Self::Num106 => serializer.serialize_u64(106),
Self::TriangleDownOpen => serializer.serialize_str("triangle-down-open"),
Self::Num206 => serializer.serialize_u64(206),
Self::TriangleDownDot => serializer.serialize_str("triangle-down-dot"),
Self::Num306 => serializer.serialize_u64(306),
Self::TriangleDownOpenDot => serializer.serialize_str("triangle-down-open-dot"),
Self::Num7 => serializer.serialize_u64(7),
Self::TriangleLeft => serializer.serialize_str("triangle-left"),
Self::Num107 => serializer.serialize_u64(107),
Self::TriangleLeftOpen => serializer.serialize_str("triangle-left-open"),
Self::Num207 => serializer.serialize_u64(207),
Self::TriangleLeftDot => serializer.serialize_str("triangle-left-dot"),
Self::Num307 => serializer.serialize_u64(307),
Self::TriangleLeftOpenDot => serializer.serialize_str("triangle-left-open-dot"),
Self::Num8 => serializer.serialize_u64(8),
Self::TriangleRight => serializer.serialize_str("triangle-right"),
Self::Num108 => serializer.serialize_u64(108),
Self::TriangleRightOpen => serializer.serialize_str("triangle-right-open"),
Self::Num208 => serializer.serialize_u64(208),
Self::TriangleRightDot => serializer.serialize_str("triangle-right-dot"),
Self::Num308 => serializer.serialize_u64(308),
Self::TriangleRightOpenDot => serializer.serialize_str("triangle-right-open-dot"),
Self::Num9 => serializer.serialize_u64(9),
Self::TriangleNe => serializer.serialize_str("triangle-ne"),
Self::Num109 => serializer.serialize_u64(109),
Self::TriangleNeOpen => serializer.serialize_str("triangle-ne-open"),
Self::Num209 => serializer.serialize_u64(209),
Self::TriangleNeDot => serializer.serialize_str("triangle-ne-dot"),
Self::Num309 => serializer.serialize_u64(309),
Self::TriangleNeOpenDot => serializer.serialize_str("triangle-ne-open-dot"),
Self::Num10 => serializer.serialize_u64(10),
Self::TriangleSe => serializer.serialize_str("triangle-se"),
Self::Num110 => serializer.serialize_u64(110),
Self::TriangleSeOpen => serializer.serialize_str("triangle-se-open"),
Self::Num210 => serializer.serialize_u64(210),
Self::TriangleSeDot => serializer.serialize_str("triangle-se-dot"),
Self::Num310 => serializer.serialize_u64(310),
Self::TriangleSeOpenDot => serializer.serialize_str("triangle-se-open-dot"),
Self::Num11 => serializer.serialize_u64(11),
Self::TriangleSw => serializer.serialize_str("triangle-sw"),
Self::Num111 => serializer.serialize_u64(111),
Self::TriangleSwOpen => serializer.serialize_str("triangle-sw-open"),
Self::Num211 => serializer.serialize_u64(211),
Self::TriangleSwDot => serializer.serialize_str("triangle-sw-dot"),
Self::Num311 => serializer.serialize_u64(311),
Self::TriangleSwOpenDot => serializer.serialize_str("triangle-sw-open-dot"),
Self::Num12 => serializer.serialize_u64(12),
Self::TriangleNw => serializer.serialize_str("triangle-nw"),
Self::Num112 => serializer.serialize_u64(112),
Self::TriangleNwOpen => serializer.serialize_str("triangle-nw-open"),
Self::Num212 => serializer.serialize_u64(212),
Self::TriangleNwDot => serializer.serialize_str("triangle-nw-dot"),
Self::Num312 => serializer.serialize_u64(312),
Self::TriangleNwOpenDot => serializer.serialize_str("triangle-nw-open-dot"),
Self::Num13 => serializer.serialize_u64(13),
Self::Pentagon => serializer.serialize_str("pentagon"),
Self::Num113 => serializer.serialize_u64(113),
Self::PentagonOpen => serializer.serialize_str("pentagon-open"),
Self::Num213 => serializer.serialize_u64(213),
Self::PentagonDot => serializer.serialize_str("pentagon-dot"),
Self::Num313 => serializer.serialize_u64(313),
Self::PentagonOpenDot => serializer.serialize_str("pentagon-open-dot"),
Self::Num14 => serializer.serialize_u64(14),
Self::Hexagon => serializer.serialize_str("hexagon"),
Self::Num114 => serializer.serialize_u64(114),
Self::HexagonOpen => serializer.serialize_str("hexagon-open"),
Self::Num214 => serializer.serialize_u64(214),
Self::HexagonDot => serializer.serialize_str("hexagon-dot"),
Self::Num314 => serializer.serialize_u64(314),
Self::HexagonOpenDot => serializer.serialize_str("hexagon-open-dot"),
Self::Num15 => serializer.serialize_u64(15),
Self::Hexagon2 => serializer.serialize_str("hexagon2"),
Self::Num115 => serializer.serialize_u64(115),
Self::Hexagon2Open => serializer.serialize_str("hexagon2-open"),
Self::Num215 => serializer.serialize_u64(215),
Self::Hexagon2Dot => serializer.serialize_str("hexagon2-dot"),
Self::Num315 => serializer.serialize_u64(315),
Self::Hexagon2OpenDot => serializer.serialize_str("hexagon2-open-dot"),
Self::Num16 => serializer.serialize_u64(16),
Self::Octagon => serializer.serialize_str("octagon"),
Self::Num116 => serializer.serialize_u64(116),
Self::OctagonOpen => serializer.serialize_str("octagon-open"),
Self::Num216 => serializer.serialize_u64(216),
Self::OctagonDot => serializer.serialize_str("octagon-dot"),
Self::Num316 => serializer.serialize_u64(316),
Self::OctagonOpenDot => serializer.serialize_str("octagon-open-dot"),
Self::Num17 => serializer.serialize_u64(17),
Self::Star => serializer.serialize_str("star"),
Self::Num117 => serializer.serialize_u64(117),
Self::StarOpen => serializer.serialize_str("star-open"),
Self::Num217 => serializer.serialize_u64(217),
Self::StarDot => serializer.serialize_str("star-dot"),
Self::Num317 => serializer.serialize_u64(317),
Self::StarOpenDot => serializer.serialize_str("star-open-dot"),
Self::Num18 => serializer.serialize_u64(18),
Self::Hexagram => serializer.serialize_str("hexagram"),
Self::Num118 => serializer.serialize_u64(118),
Self::HexagramOpen => serializer.serialize_str("hexagram-open"),
Self::Num218 => serializer.serialize_u64(218),
Self::HexagramDot => serializer.serialize_str("hexagram-dot"),
Self::Num318 => serializer.serialize_u64(318),
Self::HexagramOpenDot => serializer.serialize_str("hexagram-open-dot"),
Self::Num19 => serializer.serialize_u64(19),
Self::StarTriangleUp => serializer.serialize_str("star-triangle-up"),
Self::Num119 => serializer.serialize_u64(119),
Self::StarTriangleUpOpen => serializer.serialize_str("star-triangle-up-open"),
Self::Num219 => serializer.serialize_u64(219),
Self::StarTriangleUpDot => serializer.serialize_str("star-triangle-up-dot"),
Self::Num319 => serializer.serialize_u64(319),
Self::StarTriangleUpOpenDot => serializer.serialize_str("star-triangle-up-open-dot"),
Self::Num20 => serializer.serialize_u64(20),
Self::StarTriangleDown => serializer.serialize_str("star-triangle-down"),
Self::Num120 => serializer.serialize_u64(120),
Self::StarTriangleDownOpen => serializer.serialize_str("star-triangle-down-open"),
Self::Num220 => serializer.serialize_u64(220),
Self::StarTriangleDownDot => serializer.serialize_str("star-triangle-down-dot"),
Self::Num320 => serializer.serialize_u64(320),
Self::StarTriangleDownOpenDot => serializer.serialize_str("star-triangle-down-open-dot"),
Self::Num21 => serializer.serialize_u64(21),
Self::StarSquare => serializer.serialize_str("star-square"),
Self::Num121 => serializer.serialize_u64(121),
Self::StarSquareOpen => serializer.serialize_str("star-square-open"),
Self::Num221 => serializer.serialize_u64(221),
Self::StarSquareDot => serializer.serialize_str("star-square-dot"),
Self::Num321 => serializer.serialize_u64(321),
Self::StarSquareOpenDot => serializer.serialize_str("star-square-open-dot"),
Self::Num22 => serializer.serialize_u64(22),
Self::StarDiamond => serializer.serialize_str("star-diamond"),
Self::Num122 => serializer.serialize_u64(122),
Self::StarDiamondOpen => serializer.serialize_str("star-diamond-open"),
Self::Num222 => serializer.serialize_u64(222),
Self::StarDiamondDot => serializer.serialize_str("star-diamond-dot"),
Self::Num322 => serializer.serialize_u64(322),
Self::StarDiamondOpenDot => serializer.serialize_str("star-diamond-open-dot"),
Self::Num23 => serializer.serialize_u64(23),
Self::DiamondTall => serializer.serialize_str("diamond-tall"),
Self::Num123 => serializer.serialize_u64(123),
Self::DiamondTallOpen => serializer.serialize_str("diamond-tall-open"),
Self::Num223 => serializer.serialize_u64(223),
Self::DiamondTallDot => serializer.serialize_str("diamond-tall-dot"),
Self::Num323 => serializer.serialize_u64(323),
Self::DiamondTallOpenDot => serializer.serialize_str("diamond-tall-open-dot"),
Self::Num24 => serializer.serialize_u64(24),
Self::DiamondWide => serializer.serialize_str("diamond-wide"),
Self::Num124 => serializer.serialize_u64(124),
Self::DiamondWideOpen => serializer.serialize_str("diamond-wide-open"),
Self::Num224 => serializer.serialize_u64(224),
Self::DiamondWideDot => serializer.serialize_str("diamond-wide-dot"),
Self::Num324 => serializer.serialize_u64(324),
Self::DiamondWideOpenDot => serializer.serialize_str("diamond-wide-open-dot"),
Self::Num25 => serializer.serialize_u64(25),
Self::Hourglass => serializer.serialize_str("hourglass"),
Self::Num125 => serializer.serialize_u64(125),
Self::HourglassOpen => serializer.serialize_str("hourglass-open"),
Self::Num26 => serializer.serialize_u64(26),
Self::Bowtie => serializer.serialize_str("bowtie"),
Self::Num126 => serializer.serialize_u64(126),
Self::BowtieOpen => serializer.serialize_str("bowtie-open"),
Self::Num27 => serializer.serialize_u64(27),
Self::CircleCross => serializer.serialize_str("circle-cross"),
Self::Num127 => serializer.serialize_u64(127),
Self::CircleCrossOpen => serializer.serialize_str("circle-cross-open"),
Self::Num28 => serializer.serialize_u64(28),
Self::CircleX => serializer.serialize_str("circle-x"),
Self::Num128 => serializer.serialize_u64(128),
Self::CircleXOpen => serializer.serialize_str("circle-x-open"),
Self::Num29 => serializer.serialize_u64(29),
Self::SquareCross => serializer.serialize_str("square-cross"),
Self::Num129 => serializer.serialize_u64(129),
Self::SquareCrossOpen => serializer.serialize_str("square-cross-open"),
Self::Num30 => serializer.serialize_u64(30),
Self::SquareX => serializer.serialize_str("square-x"),
Self::Num130 => serializer.serialize_u64(130),
Self::SquareXOpen => serializer.serialize_str("square-x-open"),
Self::Num31 => serializer.serialize_u64(31),
Self::DiamondCross => serializer.serialize_str("diamond-cross"),
Self::Num131 => serializer.serialize_u64(131),
Self::DiamondCrossOpen => serializer.serialize_str("diamond-cross-open"),
Self::Num32 => serializer.serialize_u64(32),
Self::DiamondX => serializer.serialize_str("diamond-x"),
Self::Num132 => serializer.serialize_u64(132),
Self::DiamondXOpen => serializer.serialize_str("diamond-x-open"),
Self::Num33 => serializer.serialize_u64(33),
Self::CrossThin => serializer.serialize_str("cross-thin"),
Self::Num133 => serializer.serialize_u64(133),
Self::CrossThinOpen => serializer.serialize_str("cross-thin-open"),
Self::Num34 => serializer.serialize_u64(34),
Self::XThin => serializer.serialize_str("x-thin"),
Self::Num134 => serializer.serialize_u64(134),
Self::XThinOpen => serializer.serialize_str("x-thin-open"),
Self::Num35 => serializer.serialize_u64(35),
Self::Asterisk => serializer.serialize_str("asterisk"),
Self::Num135 => serializer.serialize_u64(135),
Self::AsteriskOpen => serializer.serialize_str("asterisk-open"),
Self::Num36 => serializer.serialize_u64(36),
Self::Hash => serializer.serialize_str("hash"),
Self::Num136 => serializer.serialize_u64(136),
Self::HashOpen => serializer.serialize_str("hash-open"),
Self::Num236 => serializer.serialize_u64(236),
Self::HashDot => serializer.serialize_str("hash-dot"),
Self::Num336 => serializer.serialize_u64(336),
Self::HashOpenDot => serializer.serialize_str("hash-open-dot"),
Self::Num37 => serializer.serialize_u64(37),
Self::YUp => serializer.serialize_str("y-up"),
Self::Num137 => serializer.serialize_u64(137),
Self::YUpOpen => serializer.serialize_str("y-up-open"),
Self::Num38 => serializer.serialize_u64(38),
Self::YDown => serializer.serialize_str("y-down"),
Self::Num138 => serializer.serialize_u64(138),
Self::YDownOpen => serializer.serialize_str("y-down-open"),
Self::Num39 => serializer.serialize_u64(39),
Self::YLeft => serializer.serialize_str("y-left"),
Self::Num139 => serializer.serialize_u64(139),
Self::YLeftOpen => serializer.serialize_str("y-left-open"),
Self::Num40 => serializer.serialize_u64(40),
Self::YRight => serializer.serialize_str("y-right"),
Self::Num140 => serializer.serialize_u64(140),
Self::YRightOpen => serializer.serialize_str("y-right-open"),
Self::Num41 => serializer.serialize_u64(41),
Self::LineEw => serializer.serialize_str("line-ew"),
Self::Num141 => serializer.serialize_u64(141),
Self::LineEwOpen => serializer.serialize_str("line-ew-open"),
Self::Num42 => serializer.serialize_u64(42),
Self::LineNs => serializer.serialize_str("line-ns"),
Self::Num142 => serializer.serialize_u64(142),
Self::LineNsOpen => serializer.serialize_str("line-ns-open"),
Self::Num43 => serializer.serialize_u64(43),
Self::LineNe => serializer.serialize_str("line-ne"),
Self::Num143 => serializer.serialize_u64(143),
Self::LineNeOpen => serializer.serialize_str("line-ne-open"),
Self::Num44 => serializer.serialize_u64(44),
Self::LineNw => serializer.serialize_str("line-nw"),
Self::Num144 => serializer.serialize_u64(144),
Self::LineNwOpen => serializer.serialize_str("line-nw-open"),
}
}
}
pub enum Sizemode {
Diameter,
Area,
}
impl serde::Serialize for Sizemode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Diameter => serializer.serialize_str("diameter"),
Self::Area => serializer.serialize_str("area"),
}
}
}
#[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 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 Gradient<'a> {
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
}
impl<'a> Gradient<'a> {
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
}
}
pub enum Fill {
None,
Toself,
}
impl serde::Serialize for Fill {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::None => serializer.serialize_str("none"),
Self::Toself => serializer.serialize_str("toself"),
}
}
}
#[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>,
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<f64>,
}
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
}
pub fn size(&mut self, size: f64) -> &mut Self {
self.size = Some(size);
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>,
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<f64>,
}
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
}
pub fn size(&mut self, size: f64) -> &mut Self {
self.size = Some(size);
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)]
pub struct HoverinfoFlags ([u8; 1]);
impl HoverinfoFlags {
pub fn lon(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 0; }
else { self.0[0] &= !(1 << 0); }
self
}
pub fn lat(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 1; }
else { self.0[0] &= !(1 << 1); }
self
}
pub fn location(&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("lon");
}
if (self.0[0] >> 1) & 0x1 == 1 {
v.push("lat");
}
if (self.0[0] >> 2) & 0x1 == 1 {
v.push("location");
}
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;
}
}