#[allow(unused_imports)]
use serde_json::Value;
#[derive(Debug, Serialize, Deserialize)]
pub struct Trade {
#[serde(rename = "execution_id")]
execution_id: Option<String>,
#[serde(rename = "symbol")]
symbol: Option<String>,
#[serde(rename = "side")]
side: Option<String>,
#[serde(rename = "order_description")]
order_description: Option<String>,
#[serde(rename = "trade_time")]
trade_time: Option<String>,
#[serde(rename = "trade_time_r")]
trade_time_r: Option<f32>,
#[serde(rename = "size")]
size: Option<String>,
#[serde(rename = "price")]
price: Option<String>,
#[serde(rename = "submitter")]
submitter: Option<String>,
#[serde(rename = "exchange")]
exchange: Option<String>,
#[serde(rename = "comission")]
comission: Option<f32>,
#[serde(rename = "net_amount")]
net_amount: Option<f32>,
#[serde(rename = "account")]
account: Option<String>,
#[serde(rename = "company_name")]
company_name: Option<String>,
#[serde(rename = "contract_description_1")]
contract_description_1: Option<String>,
#[serde(rename = "sec_type")]
sec_type: Option<String>,
#[serde(rename = "conidex")]
conidex: Option<String>,
#[serde(rename = "position")]
position: Option<String>,
#[serde(rename = "clearing_id")]
clearing_id: Option<String>,
#[serde(rename = "clearing_name")]
clearing_name: Option<String>
}
impl Trade {
pub fn new() -> Trade {
Trade {
execution_id: None,
symbol: None,
side: None,
order_description: None,
trade_time: None,
trade_time_r: None,
size: None,
price: None,
submitter: None,
exchange: None,
comission: None,
net_amount: None,
account: None,
company_name: None,
contract_description_1: None,
sec_type: None,
conidex: None,
position: None,
clearing_id: None,
clearing_name: None
}
}
pub fn set_execution_id(&mut self, execution_id: String) {
self.execution_id = Some(execution_id);
}
pub fn with_execution_id(mut self, execution_id: String) -> Trade {
self.execution_id = Some(execution_id);
self
}
pub fn execution_id(&self) -> Option<&String> {
self.execution_id.as_ref()
}
pub fn reset_execution_id(&mut self) {
self.execution_id = None;
}
pub fn set_symbol(&mut self, symbol: String) {
self.symbol = Some(symbol);
}
pub fn with_symbol(mut self, symbol: String) -> Trade {
self.symbol = Some(symbol);
self
}
pub fn symbol(&self) -> Option<&String> {
self.symbol.as_ref()
}
pub fn reset_symbol(&mut self) {
self.symbol = None;
}
pub fn set_side(&mut self, side: String) {
self.side = Some(side);
}
pub fn with_side(mut self, side: String) -> Trade {
self.side = Some(side);
self
}
pub fn side(&self) -> Option<&String> {
self.side.as_ref()
}
pub fn reset_side(&mut self) {
self.side = None;
}
pub fn set_order_description(&mut self, order_description: String) {
self.order_description = Some(order_description);
}
pub fn with_order_description(mut self, order_description: String) -> Trade {
self.order_description = Some(order_description);
self
}
pub fn order_description(&self) -> Option<&String> {
self.order_description.as_ref()
}
pub fn reset_order_description(&mut self) {
self.order_description = None;
}
pub fn set_trade_time(&mut self, trade_time: String) {
self.trade_time = Some(trade_time);
}
pub fn with_trade_time(mut self, trade_time: String) -> Trade {
self.trade_time = Some(trade_time);
self
}
pub fn trade_time(&self) -> Option<&String> {
self.trade_time.as_ref()
}
pub fn reset_trade_time(&mut self) {
self.trade_time = None;
}
pub fn set_trade_time_r(&mut self, trade_time_r: f32) {
self.trade_time_r = Some(trade_time_r);
}
pub fn with_trade_time_r(mut self, trade_time_r: f32) -> Trade {
self.trade_time_r = Some(trade_time_r);
self
}
pub fn trade_time_r(&self) -> Option<&f32> {
self.trade_time_r.as_ref()
}
pub fn reset_trade_time_r(&mut self) {
self.trade_time_r = None;
}
pub fn set_size(&mut self, size: String) {
self.size = Some(size);
}
pub fn with_size(mut self, size: String) -> Trade {
self.size = Some(size);
self
}
pub fn size(&self) -> Option<&String> {
self.size.as_ref()
}
pub fn reset_size(&mut self) {
self.size = None;
}
pub fn set_price(&mut self, price: String) {
self.price = Some(price);
}
pub fn with_price(mut self, price: String) -> Trade {
self.price = Some(price);
self
}
pub fn price(&self) -> Option<&String> {
self.price.as_ref()
}
pub fn reset_price(&mut self) {
self.price = None;
}
pub fn set_submitter(&mut self, submitter: String) {
self.submitter = Some(submitter);
}
pub fn with_submitter(mut self, submitter: String) -> Trade {
self.submitter = Some(submitter);
self
}
pub fn submitter(&self) -> Option<&String> {
self.submitter.as_ref()
}
pub fn reset_submitter(&mut self) {
self.submitter = None;
}
pub fn set_exchange(&mut self, exchange: String) {
self.exchange = Some(exchange);
}
pub fn with_exchange(mut self, exchange: String) -> Trade {
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_comission(&mut self, comission: f32) {
self.comission = Some(comission);
}
pub fn with_comission(mut self, comission: f32) -> Trade {
self.comission = Some(comission);
self
}
pub fn comission(&self) -> Option<&f32> {
self.comission.as_ref()
}
pub fn reset_comission(&mut self) {
self.comission = None;
}
pub fn set_net_amount(&mut self, net_amount: f32) {
self.net_amount = Some(net_amount);
}
pub fn with_net_amount(mut self, net_amount: f32) -> Trade {
self.net_amount = Some(net_amount);
self
}
pub fn net_amount(&self) -> Option<&f32> {
self.net_amount.as_ref()
}
pub fn reset_net_amount(&mut self) {
self.net_amount = None;
}
pub fn set_account(&mut self, account: String) {
self.account = Some(account);
}
pub fn with_account(mut self, account: String) -> Trade {
self.account = Some(account);
self
}
pub fn account(&self) -> Option<&String> {
self.account.as_ref()
}
pub fn reset_account(&mut self) {
self.account = None;
}
pub fn set_company_name(&mut self, company_name: String) {
self.company_name = Some(company_name);
}
pub fn with_company_name(mut self, company_name: String) -> Trade {
self.company_name = Some(company_name);
self
}
pub fn company_name(&self) -> Option<&String> {
self.company_name.as_ref()
}
pub fn reset_company_name(&mut self) {
self.company_name = None;
}
pub fn set_contract_description_1(&mut self, contract_description_1: String) {
self.contract_description_1 = Some(contract_description_1);
}
pub fn with_contract_description_1(mut self, contract_description_1: String) -> Trade {
self.contract_description_1 = Some(contract_description_1);
self
}
pub fn contract_description_1(&self) -> Option<&String> {
self.contract_description_1.as_ref()
}
pub fn reset_contract_description_1(&mut self) {
self.contract_description_1 = None;
}
pub fn set_sec_type(&mut self, sec_type: String) {
self.sec_type = Some(sec_type);
}
pub fn with_sec_type(mut self, sec_type: String) -> Trade {
self.sec_type = Some(sec_type);
self
}
pub fn sec_type(&self) -> Option<&String> {
self.sec_type.as_ref()
}
pub fn reset_sec_type(&mut self) {
self.sec_type = None;
}
pub fn set_conidex(&mut self, conidex: String) {
self.conidex = Some(conidex);
}
pub fn with_conidex(mut self, conidex: String) -> Trade {
self.conidex = Some(conidex);
self
}
pub fn conidex(&self) -> Option<&String> {
self.conidex.as_ref()
}
pub fn reset_conidex(&mut self) {
self.conidex = None;
}
pub fn set_position(&mut self, position: String) {
self.position = Some(position);
}
pub fn with_position(mut self, position: String) -> Trade {
self.position = Some(position);
self
}
pub fn position(&self) -> Option<&String> {
self.position.as_ref()
}
pub fn reset_position(&mut self) {
self.position = None;
}
pub fn set_clearing_id(&mut self, clearing_id: String) {
self.clearing_id = Some(clearing_id);
}
pub fn with_clearing_id(mut self, clearing_id: String) -> Trade {
self.clearing_id = Some(clearing_id);
self
}
pub fn clearing_id(&self) -> Option<&String> {
self.clearing_id.as_ref()
}
pub fn reset_clearing_id(&mut self) {
self.clearing_id = None;
}
pub fn set_clearing_name(&mut self, clearing_name: String) {
self.clearing_name = Some(clearing_name);
}
pub fn with_clearing_name(mut self, clearing_name: String) -> Trade {
self.clearing_name = Some(clearing_name);
self
}
pub fn clearing_name(&self) -> Option<&String> {
self.clearing_name.as_ref()
}
pub fn reset_clearing_name(&mut self) {
self.clearing_name = None;
}
}