#[allow(unused_imports)]
use serde::Serialize;
#[derive(Default, Serialize)]
pub struct Ohlc<'a> {
#[serde(rename = "visible")]
#[serde(skip_serializing_if = "Option::is_none")]
visible: Option<Visible>,
#[serde(rename = "showlegend")]
#[serde(skip_serializing_if = "Option::is_none")]
showlegend: Option<bool>,
#[serde(rename = "legendgroup")]
#[serde(skip_serializing_if = "Option::is_none")]
legendgroup: Option<&'a str>,
#[serde(rename = "opacity")]
#[serde(skip_serializing_if = "Option::is_none")]
opacity: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
name: Option<&'a str>,
#[serde(rename = "uid")]
#[serde(skip_serializing_if = "Option::is_none")]
uid: Option<&'a str>,
#[serde(rename = "ids")]
#[serde(skip_serializing_if = "Option::is_none")]
ids: Option<&'a [&'a str]>,
#[serde(rename = "meta")]
#[serde(skip_serializing_if = "Option::is_none")]
meta: Option<crate::Any>,
#[serde(rename = "selectedpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
selectedpoints: Option<crate::Any>,
#[serde(rename = "hoverinfo")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
hoverinfo: crate::IsEmpty<Hoverinfo>,
#[serde(rename = "stream")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
stream: crate::IsEmpty<Stream<'a>>,
#[serde(rename = "uirevision")]
#[serde(skip_serializing_if = "Option::is_none")]
uirevision: Option<crate::Any>,
#[serde(rename = "x")]
#[serde(skip_serializing_if = "Option::is_none")]
x: Option<&'a [f64]>,
#[serde(rename = "open")]
#[serde(skip_serializing_if = "Option::is_none")]
open: Option<&'a [f64]>,
#[serde(rename = "high")]
#[serde(skip_serializing_if = "Option::is_none")]
high: Option<&'a [f64]>,
#[serde(rename = "low")]
#[serde(skip_serializing_if = "Option::is_none")]
low: Option<&'a [f64]>,
#[serde(rename = "close")]
#[serde(skip_serializing_if = "Option::is_none")]
close: Option<&'a [f64]>,
#[serde(rename = "line")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
line: crate::IsEmpty<Line<'a>>,
#[serde(rename = "increasing")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
increasing: crate::IsEmpty<Increasing<'a>>,
#[serde(rename = "decreasing")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
decreasing: crate::IsEmpty<Decreasing<'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 = "tickwidth")]
#[serde(skip_serializing_if = "Option::is_none")]
tickwidth: Option<f64>,
#[serde(rename = "hoverlabel")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
hoverlabel: crate::IsEmpty<Hoverlabel<'a>>,
#[serde(rename = "xcalendar")]
#[serde(skip_serializing_if = "Option::is_none")]
xcalendar: Option<Xcalendar>,
#[serde(rename = "xaxis")]
#[serde(skip_serializing_if = "Option::is_none")]
xaxis: Option<&'a str>,
#[serde(rename = "yaxis")]
#[serde(skip_serializing_if = "Option::is_none")]
yaxis: Option<&'a str>,
#[serde(rename = "idssrc")]
#[serde(skip_serializing_if = "Option::is_none")]
idssrc: Option<&'a str>,
#[serde(rename = "customdatasrc")]
#[serde(skip_serializing_if = "Option::is_none")]
customdatasrc: Option<&'a str>,
#[serde(rename = "metasrc")]
#[serde(skip_serializing_if = "Option::is_none")]
metasrc: Option<&'a str>,
#[serde(rename = "hoverinfosrc")]
#[serde(skip_serializing_if = "Option::is_none")]
hoverinfosrc: Option<&'a str>,
#[serde(rename = "xsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
xsrc: Option<&'a str>,
#[serde(rename = "opensrc")]
#[serde(skip_serializing_if = "Option::is_none")]
opensrc: Option<&'a str>,
#[serde(rename = "highsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
highsrc: Option<&'a str>,
#[serde(rename = "lowsrc")]
#[serde(skip_serializing_if = "Option::is_none")]
lowsrc: Option<&'a str>,
#[serde(rename = "closesrc")]
#[serde(skip_serializing_if = "Option::is_none")]
closesrc: 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>,
}
impl<'a> Ohlc<'a> {
pub fn visible(&mut self, visible: Visible) -> &mut Self {
self.visible = Some(visible);
self
}
pub fn showlegend(&mut self, showlegend: bool) -> &mut Self {
self.showlegend = Some(showlegend);
self
}
pub fn legendgroup(&mut self, legendgroup: &'a str) -> &mut Self {
self.legendgroup = Some(legendgroup);
self
}
pub fn opacity(&mut self, opacity: f64) -> &mut Self {
self.opacity = Some(opacity);
self
}
pub fn name(&mut self, name: &'a str) -> &mut Self {
self.name = Some(name);
self
}
pub fn uid(&mut self, uid: &'a str) -> &mut Self {
self.uid = Some(uid);
self
}
pub fn ids(&mut self, ids: &'a [&'a str]) -> &mut Self {
self.ids = Some(ids);
self
}
pub fn meta(&mut self, meta: crate::Any) -> &mut Self {
self.meta = Some(meta);
self
}
pub fn selectedpoints(&mut self, selectedpoints: crate::Any) -> &mut Self {
self.selectedpoints = Some(selectedpoints);
self
}
pub fn hoverinfo(&mut self) -> &mut Hoverinfo {
self.hoverinfo.is_empty = false;
&mut self.hoverinfo.data
}
pub fn stream(&mut self) -> &mut Stream<'a> {
self.stream.is_empty = false;
&mut self.stream.data
}
pub fn uirevision(&mut self, uirevision: crate::Any) -> &mut Self {
self.uirevision = Some(uirevision);
self
}
pub fn x(&mut self, x: &'a [f64]) -> &mut Self {
self.x = Some(x);
self
}
pub fn open(&mut self, open: &'a [f64]) -> &mut Self {
self.open = Some(open);
self
}
pub fn high(&mut self, high: &'a [f64]) -> &mut Self {
self.high = Some(high);
self
}
pub fn low(&mut self, low: &'a [f64]) -> &mut Self {
self.low = Some(low);
self
}
pub fn close(&mut self, close: &'a [f64]) -> &mut Self {
self.close = Some(close);
self
}
pub fn line(&mut self) -> &mut Line<'a> {
self.line.is_empty = false;
&mut self.line.data
}
pub fn increasing(&mut self) -> &mut Increasing<'a> {
self.increasing.is_empty = false;
&mut self.increasing.data
}
pub fn decreasing(&mut self) -> &mut Decreasing<'a> {
self.decreasing.is_empty = false;
&mut self.decreasing.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 tickwidth(&mut self, tickwidth: f64) -> &mut Self {
self.tickwidth = Some(tickwidth);
self
}
pub fn hoverlabel(&mut self) -> &mut Hoverlabel<'a> {
self.hoverlabel.is_empty = false;
&mut self.hoverlabel.data
}
pub fn xcalendar(&mut self, xcalendar: Xcalendar) -> &mut Self {
self.xcalendar = Some(xcalendar);
self
}
pub fn xaxis(&mut self, xaxis: &'a str) -> &mut Self {
self.xaxis = Some(xaxis);
self
}
pub fn yaxis(&mut self, yaxis: &'a str) -> &mut Self {
self.yaxis = Some(yaxis);
self
}
pub fn idssrc(&mut self, idssrc: &'a str) -> &mut Self {
self.idssrc = Some(idssrc);
self
}
pub fn customdatasrc(&mut self, customdatasrc: &'a str) -> &mut Self {
self.customdatasrc = Some(customdatasrc);
self
}
pub fn metasrc(&mut self, metasrc: &'a str) -> &mut Self {
self.metasrc = Some(metasrc);
self
}
pub fn hoverinfosrc(&mut self, hoverinfosrc: &'a str) -> &mut Self {
self.hoverinfosrc = Some(hoverinfosrc);
self
}
pub fn xsrc(&mut self, xsrc: &'a str) -> &mut Self {
self.xsrc = Some(xsrc);
self
}
pub fn opensrc(&mut self, opensrc: &'a str) -> &mut Self {
self.opensrc = Some(opensrc);
self
}
pub fn highsrc(&mut self, highsrc: &'a str) -> &mut Self {
self.highsrc = Some(highsrc);
self
}
pub fn lowsrc(&mut self, lowsrc: &'a str) -> &mut Self {
self.lowsrc = Some(lowsrc);
self
}
pub fn closesrc(&mut self, closesrc: &'a str) -> &mut Self {
self.closesrc = Some(closesrc);
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 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 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
}
}
#[derive(Default, Serialize)]
pub struct Line<'a> {
#[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 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 Increasing<'a> {
#[serde(rename = "line")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
line: crate::IsEmpty<increasing::Line<'a>>,
}
impl<'a> Increasing<'a> {
pub fn line(&mut self) -> &mut increasing::Line<'a> {
self.line.is_empty = false;
&mut self.line.data
}
}
pub mod increasing {
#[allow(unused_imports)]
use serde::Serialize;
#[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 Decreasing<'a> {
#[serde(rename = "line")]
#[serde(skip_serializing_if = "crate::IsEmpty::is_empty")]
line: crate::IsEmpty<decreasing::Line<'a>>,
}
impl<'a> Decreasing<'a> {
pub fn line(&mut self) -> &mut decreasing::Line<'a> {
self.line.is_empty = false;
&mut self.line.data
}
}
pub mod decreasing {
#[allow(unused_imports)]
use serde::Serialize;
#[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 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>,
#[serde(rename = "split")]
#[serde(skip_serializing_if = "Option::is_none")]
split: Option<bool>,
}
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 fn split(&mut self, split: bool) -> &mut Self {
self.split = Some(split);
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"),
}
}
}
}
pub enum Xcalendar {
Gregorian,
Chinese,
Coptic,
Discworld,
Ethiopian,
Hebrew,
Islamic,
Julian,
Mayan,
Nanakshahi,
Nepali,
Persian,
Jalali,
Taiwan,
Thai,
Ummalqura,
}
impl serde::Serialize for Xcalendar {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Self::Gregorian => serializer.serialize_str("gregorian"),
Self::Chinese => serializer.serialize_str("chinese"),
Self::Coptic => serializer.serialize_str("coptic"),
Self::Discworld => serializer.serialize_str("discworld"),
Self::Ethiopian => serializer.serialize_str("ethiopian"),
Self::Hebrew => serializer.serialize_str("hebrew"),
Self::Islamic => serializer.serialize_str("islamic"),
Self::Julian => serializer.serialize_str("julian"),
Self::Mayan => serializer.serialize_str("mayan"),
Self::Nanakshahi => serializer.serialize_str("nanakshahi"),
Self::Nepali => serializer.serialize_str("nepali"),
Self::Persian => serializer.serialize_str("persian"),
Self::Jalali => serializer.serialize_str("jalali"),
Self::Taiwan => serializer.serialize_str("taiwan"),
Self::Thai => serializer.serialize_str("thai"),
Self::Ummalqura => serializer.serialize_str("ummalqura"),
}
}
}