#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Violin<'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 = "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 = "y")]
#[serde(skip_serializing_if = "Option::is_none")]
y: Option<&'a [f64]>,
#[serde(rename = "x")]
#[serde(skip_serializing_if = "Option::is_none")]
x: Option<&'a [f64]>,
#[serde(rename = "x0")]
#[serde(skip_serializing_if = "Option::is_none")]
x_0: Option<crate::Any>,
#[serde(rename = "y0")]
#[serde(skip_serializing_if = "Option::is_none")]
y_0: Option<crate::Any>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
name: Option<&'a str>,
#[serde(rename = "orientation")]
#[serde(skip_serializing_if = "Option::is_none")]
orientation: Option<Orientation>,
#[serde(rename = "bandwidth")]
#[serde(skip_serializing_if = "Option::is_none")]
bandwidth: Option<f64>,
#[serde(rename = "scalegroup")]
#[serde(skip_serializing_if = "Option::is_none")]
scalegroup: Option<&'a str>,
#[serde(rename = "scalemode")]
#[serde(skip_serializing_if = "Option::is_none")]
scalemode: Option<Scalemode>,
#[serde(rename = "spanmode")]
#[serde(skip_serializing_if = "Option::is_none")]
spanmode: Option<Spanmode>,
#[serde(rename = "span")]
#[serde(skip_serializing_if = "Option::is_none")]
span: Option<&'a crate::InfoArray>,
#[serde(rename = "line")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
line: crate::IsEmpty<Line<'a>>,
#[serde(rename = "fillcolor")]
#[serde(skip_serializing_if = "Option::is_none")]
fillcolor: Option<&'a str>,
#[serde(rename = "points")]
#[serde(skip_serializing_if = "Option::is_none")]
points: Option<Points>,
#[serde(rename = "jitter")]
#[serde(skip_serializing_if = "Option::is_none")]
jitter: Option<f64>,
#[serde(rename = "pointpos")]
#[serde(skip_serializing_if = "Option::is_none")]
pointpos: Option<f64>,
#[serde(rename = "width")]
#[serde(skip_serializing_if = "Option::is_none")]
width: Option<f64>,
#[serde(rename = "marker")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
marker: crate::IsEmpty<Marker<'a>>,
#[serde(rename = "text")]
#[serde(skip_serializing_if = "Option::is_none")]
text: Option<&'a str>,
#[serde(rename = "hovertext")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertext: Option<&'a str>,
#[serde(rename = "hovertemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
hovertemplate: Option<&'a str>,
#[serde(rename = "meanline")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
meanline: crate::IsEmpty<Meanline<'a>>,
#[serde(rename = "side")]
#[serde(skip_serializing_if = "Option::is_none")]
side: Option<Side>,
#[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 = "hoveron")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
hoveron: crate::IsEmpty<Hoveron>,
#[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 = "ysrc")]
#[serde(skip_serializing_if = "Option::is_none")]
ysrc: Option<&'a str>,
#[serde(rename = "xsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
xsrc: 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> Violin<'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 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 y(&mut self, y: &'a [f64]) -> &mut Self {
self.y = Some(y);
self
}
pub fn x(&mut self, x: &'a [f64]) -> &mut Self {
self.x = Some(x);
self
}
pub fn x_0(&mut self, x_0: crate::Any) -> &mut Self {
self.x_0 = Some(x_0);
self
}
pub fn y_0(&mut self, y_0: crate::Any) -> &mut Self {
self.y_0 = Some(y_0);
self
}
pub fn name(&mut self, name: &'a str) -> &mut Self {
self.name = Some(name);
self
}
pub fn orientation(&mut self, orientation: Orientation) -> &mut Self {
self.orientation = Some(orientation);
self
}
pub fn bandwidth(&mut self, bandwidth: f64) -> &mut Self {
self.bandwidth = Some(bandwidth);
self
}
pub fn scalegroup(&mut self, scalegroup: &'a str) -> &mut Self {
self.scalegroup = Some(scalegroup);
self
}
pub fn scalemode(&mut self, scalemode: Scalemode) -> &mut Self {
self.scalemode = Some(scalemode);
self
}
pub fn spanmode(&mut self, spanmode: Spanmode) -> &mut Self {
self.spanmode = Some(spanmode);
self
}
pub fn span(&mut self, span: &'a crate::InfoArray) -> &mut Self {
self.span = Some(span);
self
}
pub fn line(&mut self) -> &mut Line<'a> {
self.line.is_empty = false;
&mut self.line.data
}
pub fn fillcolor(&mut self, fillcolor: &'a str) -> &mut Self {
self.fillcolor = Some(fillcolor);
self
}
pub fn points(&mut self, points: Points) -> &mut Self {
self.points = Some(points);
self
}
pub fn jitter(&mut self, jitter: f64) -> &mut Self {
self.jitter = Some(jitter);
self
}
pub fn pointpos(&mut self, pointpos: f64) -> &mut Self {
self.pointpos = Some(pointpos);
self
}
pub fn width(&mut self, width: f64) -> &mut Self {
self.width = Some(width);
self
}
pub fn marker(&mut self) -> &mut Marker<'a> {
self.marker.is_empty = false;
&mut self.marker.data
}
pub fn text(&mut self, text: &'a str) -> &mut Self {
self.text = Some(text);
self
}
pub fn hovertext(&mut self, hovertext: &'a str) -> &mut Self {
self.hovertext = Some(hovertext);
self
}
pub fn hovertemplate(&mut self, hovertemplate: &'a str) -> &mut Self {
self.hovertemplate = Some(hovertemplate);
self
}
pub fn meanline(&mut self) -> &mut Meanline<'a> {
self.meanline.is_empty = false;
&mut self.meanline.data
}
pub fn side(&mut self, side: Side) -> &mut Self {
self.side = Some(side);
self
}
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 hoveron(&mut self) -> &mut Hoveron {
self.hoveron.is_empty = false;
&mut self.hoveron.data
}
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 ysrc(&mut self, ysrc: &'a str) -> &mut Self {
self.ysrc = Some(ysrc);
self
}
pub fn xsrc(&mut self, xsrc: &'a str) -> &mut Self {
self.xsrc = Some(xsrc);
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 Scalemode {
Width,
Count,
}
impl serde::Serialize for Scalemode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Width => serializer.serialize_str("width"),
Self::Count => serializer.serialize_str("count"),
}
}
}
pub enum Spanmode {
Soft,
Hard,
Manual,
}
impl serde::Serialize for Spanmode {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Soft => serializer.serialize_str("soft"),
Self::Hard => serializer.serialize_str("hard"),
Self::Manual => serializer.serialize_str("manual"),
}
}
}
#[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>,
}
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 enum Points {
All,
Outliers,
Suspectedoutliers,
False,
}
impl serde::Serialize for Points {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::All => serializer.serialize_str("all"),
Self::Outliers => serializer.serialize_str("outliers"),
Self::Suspectedoutliers => serializer.serialize_str("suspectedoutliers"),
Self::False => serializer.serialize_bool(false),
}
}
}
#[derive(Default, Serialize)]
pub struct Marker<'a> {
#[serde(rename = "outliercolor")]
#[serde(skip_serializing_if = "Option::is_none")]
outliercolor: Option<&'a str>,
#[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 = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
#[serde(rename = "line")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
line: crate::IsEmpty<marker::Line<'a>>,
}
impl<'a> Marker<'a> {
pub fn outliercolor(&mut self, outliercolor: &'a str) -> &mut Self {
self.outliercolor = Some(outliercolor);
self
}
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 color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
pub fn line(&mut self) -> &mut marker::Line<'a> {
self.line.is_empty = false;
&mut self.line.data
}
}
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"),
}
}
}
#[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 = "outliercolor")]
#[serde(skip_serializing_if = "Option::is_none")]
outliercolor: Option<&'a str>,
#[serde(rename = "outlierwidth")]
#[serde(skip_serializing_if = "Option::is_none")]
outlierwidth: Option<f64>,
}
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 outliercolor(&mut self, outliercolor: &'a str) -> &mut Self {
self.outliercolor = Some(outliercolor);
self
}
pub fn outlierwidth(&mut self, outlierwidth: f64) -> &mut Self {
self.outlierwidth = Some(outlierwidth);
self
}
}
}
#[derive(Default, Serialize)]
pub struct Meanline<'a> {
#[serde(rename = "visible")]
#[serde(skip_serializing_if = "Option::is_none")]
visible: Option<bool>,
#[serde(rename = "color")]
#[serde(skip_serializing_if = "Option::is_none")]
color: Option<&'a str>,
#[serde(rename = "width")]
#[serde(skip_serializing_if = "Option::is_none")]
width: Option<f64>,
}
impl<'a> Meanline<'a> {
pub fn visible(&mut self, visible: bool) -> &mut Self {
self.visible = Some(visible);
self
}
pub fn color(&mut self, color: &'a str) -> &mut Self {
self.color = Some(color);
self
}
pub fn width(&mut self, width: f64) -> &mut Self {
self.width = Some(width);
self
}
}
pub enum Side {
Both,
Positive,
Negative,
}
impl serde::Serialize for Side {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Both => serializer.serialize_str("both"),
Self::Positive => serializer.serialize_str("positive"),
Self::Negative => serializer.serialize_str("negative"),
}
}
}
#[derive(Default, Serialize)]
pub struct Selected<'a> {
#[serde(rename = "marker")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
marker: crate::IsEmpty<selected::Marker<'a>>,
}
impl<'a> Selected<'a> {
pub fn marker(&mut self) -> &mut selected::Marker<'a> {
self.marker.is_empty = false;
&mut self.marker.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 Unselected<'a> {
#[serde(rename = "marker")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
marker: crate::IsEmpty<unselected::Marker<'a>>,
}
impl<'a> Unselected<'a> {
pub fn marker(&mut self) -> &mut unselected::Marker<'a> {
self.marker.is_empty = false;
&mut self.marker.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)]
pub struct HoveronFlags ([u8; 1]);
impl HoveronFlags {
pub fn violins(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 0; }
else { self.0[0] &= !(1 << 0); }
self
}
pub fn points(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 1; }
else { self.0[0] &= !(1 << 1); }
self
}
pub fn kde(&mut self, v: bool) -> &mut Self {
if v { self.0[0] |= 1 << 2; }
else { self.0[0] &= !(1 << 2); }
self
}
}
impl serde::Serialize for HoveronFlags {
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("violins");
}
if (self.0[0] >> 1) & 0x1 == 1 {
v.push("points");
}
if (self.0[0] >> 2) & 0x1 == 1 {
v.push("kde");
}
serializer.serialize_str(&v.join("+"))
}
}
pub enum Hoveron {
Flags(HoveronFlags),
All,
}
impl serde::Serialize for Hoveron {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::All => serializer.serialize_str("all"),
Self::Flags(v) => v.serialize(serializer),
}
}
}
impl Default for Hoveron {
fn default() -> Self {
Self::Flags(HoveronFlags::default())
}
}
impl Hoveron {
pub fn flags(&mut self) -> &mut HoveronFlags {
*self = Self::Flags(HoveronFlags::default());
match self {
Self::Flags(v) => v,
_ => unreachable!(),
}
}
pub fn set(&mut self, v: Hoveron) {
*self = v;
}
}