#[allow(unused_imports)]
use serde_json::Value;
#[derive(Debug, Serialize, Deserialize)]
pub struct MarketData {
#[serde(rename = "Ask")]
ask: Option<f32>,
#[serde(rename = "AskSize")]
ask_size: Option<f32>,
#[serde(rename = "Bid")]
bid: Option<f32>,
#[serde(rename = "BidSize")]
bid_size: Option<f32>,
#[serde(rename = "Conid")]
conid: Option<f32>,
#[serde(rename = "Exchange")]
exchange: Option<String>,
#[serde(rename = "Last")]
last: Option<f32>,
#[serde(rename = "LastSize")]
last_size: Option<f32>,
#[serde(rename = "minTick")]
min_tick: Option<f32>
}
impl MarketData {
pub fn new() -> MarketData {
MarketData {
ask: None,
ask_size: None,
bid: None,
bid_size: None,
conid: None,
exchange: None,
last: None,
last_size: None,
min_tick: None
}
}
pub fn set_ask(&mut self, ask: f32) {
self.ask = Some(ask);
}
pub fn with_ask(mut self, ask: f32) -> MarketData {
self.ask = Some(ask);
self
}
pub fn ask(&self) -> Option<&f32> {
self.ask.as_ref()
}
pub fn reset_ask(&mut self) {
self.ask = None;
}
pub fn set_ask_size(&mut self, ask_size: f32) {
self.ask_size = Some(ask_size);
}
pub fn with_ask_size(mut self, ask_size: f32) -> MarketData {
self.ask_size = Some(ask_size);
self
}
pub fn ask_size(&self) -> Option<&f32> {
self.ask_size.as_ref()
}
pub fn reset_ask_size(&mut self) {
self.ask_size = None;
}
pub fn set_bid(&mut self, bid: f32) {
self.bid = Some(bid);
}
pub fn with_bid(mut self, bid: f32) -> MarketData {
self.bid = Some(bid);
self
}
pub fn bid(&self) -> Option<&f32> {
self.bid.as_ref()
}
pub fn reset_bid(&mut self) {
self.bid = None;
}
pub fn set_bid_size(&mut self, bid_size: f32) {
self.bid_size = Some(bid_size);
}
pub fn with_bid_size(mut self, bid_size: f32) -> MarketData {
self.bid_size = Some(bid_size);
self
}
pub fn bid_size(&self) -> Option<&f32> {
self.bid_size.as_ref()
}
pub fn reset_bid_size(&mut self) {
self.bid_size = None;
}
pub fn set_conid(&mut self, conid: f32) {
self.conid = Some(conid);
}
pub fn with_conid(mut self, conid: f32) -> MarketData {
self.conid = Some(conid);
self
}
pub fn conid(&self) -> Option<&f32> {
self.conid.as_ref()
}
pub fn reset_conid(&mut self) {
self.conid = None;
}
pub fn set_exchange(&mut self, exchange: String) {
self.exchange = Some(exchange);
}
pub fn with_exchange(mut self, exchange: String) -> MarketData {
self.exchange = Some(exchange);
self
}
pub fn exchange(&self) -> Option<&String> {
self.exchange.as_ref()
}
pub fn reset_exchange(&mut self) {
self.exchange = None;
}
pub fn set_last(&mut self, last: f32) {
self.last = Some(last);
}
pub fn with_last(mut self, last: f32) -> MarketData {
self.last = Some(last);
self
}
pub fn last(&self) -> Option<&f32> {
self.last.as_ref()
}
pub fn reset_last(&mut self) {
self.last = None;
}
pub fn set_last_size(&mut self, last_size: f32) {
self.last_size = Some(last_size);
}
pub fn with_last_size(mut self, last_size: f32) -> MarketData {
self.last_size = Some(last_size);
self
}
pub fn last_size(&self) -> Option<&f32> {
self.last_size.as_ref()
}
pub fn reset_last_size(&mut self) {
self.last_size = None;
}
pub fn set_min_tick(&mut self, min_tick: f32) {
self.min_tick = Some(min_tick);
}
pub fn with_min_tick(mut self, min_tick: f32) -> MarketData {
self.min_tick = Some(min_tick);
self
}
pub fn min_tick(&self) -> Option<&f32> {
self.min_tick.as_ref()
}
pub fn reset_min_tick(&mut self) {
self.min_tick = None;
}
}