Struct ExecutionReport 

pub struct ExecutionReport(pub Message);

ExecutionReport (35=8).

Tuple Fields

0: Message

Implementations

impl ExecutionReport

pub const MSG_TYPE: &'static str = "8"

pub fn new( order_id: impl Into<String>, exec_id: impl Into<String>, exec_type: char, ord_status: char, side: char, leaves_qty: Amount, cum_qty: Amount, avg_px: Amount, ) -> Self

pub fn from_message(msg: Message) -> Result<Self, Message>

Wrap a generic message; fails unless 35=“8”.

pub fn order_id(&self) -> Result<String, ConversionError>

pub fn set_order_id(&mut self, v: impl Into<String>)

pub fn has_order_id(&self) -> bool

pub fn secondary_order_id(&self) -> Result<String, ConversionError>

pub fn set_secondary_order_id(&mut self, v: impl Into<String>)

pub fn has_secondary_order_id(&self) -> bool

pub fn secondary_cl_ord_id(&self) -> Result<String, ConversionError>

pub fn set_secondary_cl_ord_id(&mut self, v: impl Into<String>)

pub fn has_secondary_cl_ord_id(&self) -> bool

pub fn secondary_exec_id(&self) -> Result<String, ConversionError>

pub fn set_secondary_exec_id(&mut self, v: impl Into<String>)

pub fn has_secondary_exec_id(&self) -> bool

pub fn cl_ord_id(&self) -> Result<String, ConversionError>

pub fn set_cl_ord_id(&mut self, v: impl Into<String>)

pub fn has_cl_ord_id(&self) -> bool

pub fn orig_cl_ord_id(&self) -> Result<String, ConversionError>

pub fn set_orig_cl_ord_id(&mut self, v: impl Into<String>)

pub fn has_orig_cl_ord_id(&self) -> bool

pub fn cl_ord_link_id(&self) -> Result<String, ConversionError>

pub fn set_cl_ord_link_id(&mut self, v: impl Into<String>)

pub fn has_cl_ord_link_id(&self) -> bool

pub fn quote_resp_id(&self) -> Result<String, ConversionError>

pub fn set_quote_resp_id(&mut self, v: impl Into<String>)

pub fn has_quote_resp_id(&self) -> bool

pub fn ord_status_req_id(&self) -> Result<String, ConversionError>

pub fn set_ord_status_req_id(&mut self, v: impl Into<String>)

pub fn has_ord_status_req_id(&self) -> bool

pub fn mass_status_req_id(&self) -> Result<String, ConversionError>

pub fn set_mass_status_req_id(&mut self, v: impl Into<String>)

pub fn has_mass_status_req_id(&self) -> bool

pub fn tot_num_reports(&self) -> Result<i64, ConversionError>

pub fn set_tot_num_reports(&mut self, v: i64)

pub fn has_tot_num_reports(&self) -> bool

pub fn last_rpt_requested(&self) -> Result<bool, ConversionError>

pub fn set_last_rpt_requested(&mut self, v: bool)

pub fn has_last_rpt_requested(&self) -> bool

pub fn no_party_ids(&self) -> Result<Vec<NoPartyIDs>, ConversionError>

pub fn set_no_party_ids(&mut self, groups: impl IntoIterator<Item = NoPartyIDs>)

pub fn trade_origination_date(&self) -> Result<FixDate, ConversionError>

pub fn set_trade_origination_date(&mut self, v: FixDate)

pub fn has_trade_origination_date(&self) -> bool

pub fn no_contra_brokers(&self) -> Result<Vec<NoContraBrokers>, ConversionError>

pub fn set_no_contra_brokers( &mut self, groups: impl IntoIterator<Item = NoContraBrokers>, )

pub fn list_id(&self) -> Result<String, ConversionError>

pub fn set_list_id(&mut self, v: impl Into<String>)

pub fn has_list_id(&self) -> bool

pub fn cross_id(&self) -> Result<String, ConversionError>

pub fn set_cross_id(&mut self, v: impl Into<String>)

pub fn has_cross_id(&self) -> bool

pub fn orig_cross_id(&self) -> Result<String, ConversionError>

pub fn set_orig_cross_id(&mut self, v: impl Into<String>)

pub fn has_orig_cross_id(&self) -> bool

pub fn cross_type(&self) -> Result<i64, ConversionError>

pub fn set_cross_type(&mut self, v: i64)

pub fn has_cross_type(&self) -> bool

pub fn exec_id(&self) -> Result<String, ConversionError>

pub fn set_exec_id(&mut self, v: impl Into<String>)

pub fn has_exec_id(&self) -> bool

pub fn exec_ref_id(&self) -> Result<String, ConversionError>

pub fn set_exec_ref_id(&mut self, v: impl Into<String>)

pub fn has_exec_ref_id(&self) -> bool

pub fn exec_type(&self) -> Result<char, ConversionError>

pub fn set_exec_type(&mut self, v: char)

pub fn has_exec_type(&self) -> bool

pub fn ord_status(&self) -> Result<char, ConversionError>

pub fn set_ord_status(&mut self, v: char)

pub fn has_ord_status(&self) -> bool

pub fn working_indicator(&self) -> Result<bool, ConversionError>

pub fn set_working_indicator(&mut self, v: bool)

pub fn has_working_indicator(&self) -> bool

pub fn ord_rej_reason(&self) -> Result<i64, ConversionError>

pub fn set_ord_rej_reason(&mut self, v: i64)

pub fn has_ord_rej_reason(&self) -> bool

pub fn exec_restatement_reason(&self) -> Result<i64, ConversionError>

pub fn set_exec_restatement_reason(&mut self, v: i64)

pub fn has_exec_restatement_reason(&self) -> bool

pub fn account(&self) -> Result<String, ConversionError>

pub fn set_account(&mut self, v: impl Into<String>)

pub fn has_account(&self) -> bool

pub fn acct_id_source(&self) -> Result<i64, ConversionError>

pub fn set_acct_id_source(&mut self, v: i64)

pub fn has_acct_id_source(&self) -> bool

pub fn account_type(&self) -> Result<i64, ConversionError>

pub fn set_account_type(&mut self, v: i64)

pub fn has_account_type(&self) -> bool

pub fn day_booking_inst(&self) -> Result<char, ConversionError>

pub fn set_day_booking_inst(&mut self, v: char)

pub fn has_day_booking_inst(&self) -> bool

pub fn booking_unit(&self) -> Result<char, ConversionError>

pub fn set_booking_unit(&mut self, v: char)

pub fn has_booking_unit(&self) -> bool

pub fn prealloc_method(&self) -> Result<char, ConversionError>

pub fn set_prealloc_method(&mut self, v: char)

pub fn has_prealloc_method(&self) -> bool

pub fn settl_type(&self) -> Result<char, ConversionError>

pub fn set_settl_type(&mut self, v: char)

pub fn has_settl_type(&self) -> bool

pub fn settl_date(&self) -> Result<FixDate, ConversionError>

pub fn set_settl_date(&mut self, v: FixDate)

pub fn has_settl_date(&self) -> bool

pub fn cash_margin(&self) -> Result<char, ConversionError>

pub fn set_cash_margin(&mut self, v: char)

pub fn has_cash_margin(&self) -> bool

pub fn clearing_fee_indicator(&self) -> Result<String, ConversionError>

pub fn set_clearing_fee_indicator(&mut self, v: impl Into<String>)

pub fn has_clearing_fee_indicator(&self) -> bool

pub fn symbol(&self) -> Result<String, ConversionError>

pub fn set_symbol(&mut self, v: impl Into<String>)

pub fn has_symbol(&self) -> bool

pub fn symbol_sfx(&self) -> Result<String, ConversionError>

pub fn set_symbol_sfx(&mut self, v: impl Into<String>)

pub fn has_symbol_sfx(&self) -> bool

pub fn security_id(&self) -> Result<String, ConversionError>

pub fn set_security_id(&mut self, v: impl Into<String>)

pub fn has_security_id(&self) -> bool

pub fn security_id_source(&self) -> Result<String, ConversionError>

pub fn set_security_id_source(&mut self, v: impl Into<String>)

pub fn has_security_id_source(&self) -> bool

pub fn no_security_alt_id( &self, ) -> Result<Vec<NoSecurityAltID>, ConversionError>

pub fn set_no_security_alt_id( &mut self, groups: impl IntoIterator<Item = NoSecurityAltID>, )

pub fn product(&self) -> Result<i64, ConversionError>

pub fn set_product(&mut self, v: i64)

pub fn has_product(&self) -> bool

pub fn cfi_code(&self) -> Result<String, ConversionError>

pub fn set_cfi_code(&mut self, v: impl Into<String>)

pub fn has_cfi_code(&self) -> bool

pub fn security_type(&self) -> Result<String, ConversionError>

pub fn set_security_type(&mut self, v: impl Into<String>)

pub fn has_security_type(&self) -> bool

pub fn security_sub_type(&self) -> Result<String, ConversionError>

pub fn set_security_sub_type(&mut self, v: impl Into<String>)

pub fn has_security_sub_type(&self) -> bool

pub fn maturity_month_year(&self) -> Result<String, ConversionError>

pub fn set_maturity_month_year(&mut self, v: impl Into<String>)

pub fn has_maturity_month_year(&self) -> bool

pub fn maturity_date(&self) -> Result<FixDate, ConversionError>

pub fn set_maturity_date(&mut self, v: FixDate)

pub fn has_maturity_date(&self) -> bool

pub fn coupon_payment_date(&self) -> Result<FixDate, ConversionError>

pub fn set_coupon_payment_date(&mut self, v: FixDate)

pub fn has_coupon_payment_date(&self) -> bool

pub fn issue_date(&self) -> Result<FixDate, ConversionError>

pub fn set_issue_date(&mut self, v: FixDate)

pub fn has_issue_date(&self) -> bool

pub fn repo_collateral_security_type(&self) -> Result<i64, ConversionError>

pub fn set_repo_collateral_security_type(&mut self, v: i64)

pub fn has_repo_collateral_security_type(&self) -> bool

pub fn repurchase_term(&self) -> Result<i64, ConversionError>

pub fn set_repurchase_term(&mut self, v: i64)

pub fn has_repurchase_term(&self) -> bool

pub fn repurchase_rate(&self) -> Result<Amount, ConversionError>

pub fn set_repurchase_rate(&mut self, v: Amount)

pub fn has_repurchase_rate(&self) -> bool

pub fn factor(&self) -> Result<Amount, ConversionError>

pub fn set_factor(&mut self, v: Amount)

pub fn has_factor(&self) -> bool

pub fn credit_rating(&self) -> Result<String, ConversionError>

pub fn set_credit_rating(&mut self, v: impl Into<String>)

pub fn has_credit_rating(&self) -> bool

pub fn instr_registry(&self) -> Result<String, ConversionError>

pub fn set_instr_registry(&mut self, v: impl Into<String>)

pub fn has_instr_registry(&self) -> bool

pub fn country_of_issue(&self) -> Result<String, ConversionError>

pub fn set_country_of_issue(&mut self, v: impl Into<String>)

pub fn has_country_of_issue(&self) -> bool

pub fn state_or_province_of_issue(&self) -> Result<String, ConversionError>

pub fn set_state_or_province_of_issue(&mut self, v: impl Into<String>)

pub fn has_state_or_province_of_issue(&self) -> bool

pub fn locale_of_issue(&self) -> Result<String, ConversionError>

pub fn set_locale_of_issue(&mut self, v: impl Into<String>)

pub fn has_locale_of_issue(&self) -> bool

pub fn redemption_date(&self) -> Result<FixDate, ConversionError>

pub fn set_redemption_date(&mut self, v: FixDate)

pub fn has_redemption_date(&self) -> bool

pub fn strike_price(&self) -> Result<Amount, ConversionError>

pub fn set_strike_price(&mut self, v: Amount)

pub fn has_strike_price(&self) -> bool

pub fn strike_currency(&self) -> Result<String, ConversionError>

pub fn set_strike_currency(&mut self, v: impl Into<String>)

pub fn has_strike_currency(&self) -> bool

pub fn opt_attribute(&self) -> Result<char, ConversionError>

pub fn set_opt_attribute(&mut self, v: char)

pub fn has_opt_attribute(&self) -> bool

pub fn contract_multiplier(&self) -> Result<Amount, ConversionError>

pub fn set_contract_multiplier(&mut self, v: Amount)

pub fn has_contract_multiplier(&self) -> bool

pub fn coupon_rate(&self) -> Result<Amount, ConversionError>

pub fn set_coupon_rate(&mut self, v: Amount)

pub fn has_coupon_rate(&self) -> bool

pub fn security_exchange(&self) -> Result<String, ConversionError>

pub fn set_security_exchange(&mut self, v: impl Into<String>)

pub fn has_security_exchange(&self) -> bool

pub fn issuer(&self) -> Result<String, ConversionError>

pub fn set_issuer(&mut self, v: impl Into<String>)

pub fn has_issuer(&self) -> bool

pub fn encoded_issuer_len(&self) -> Result<i64, ConversionError>

pub fn set_encoded_issuer_len(&mut self, v: i64)

pub fn has_encoded_issuer_len(&self) -> bool

pub fn encoded_issuer(&self) -> Result<Vec<u8>, ConversionError>

pub fn set_encoded_issuer(&mut self, v: impl Into<Vec<u8>>)

pub fn has_encoded_issuer(&self) -> bool

pub fn security_desc(&self) -> Result<String, ConversionError>

pub fn set_security_desc(&mut self, v: impl Into<String>)

pub fn has_security_desc(&self) -> bool

pub fn encoded_security_desc_len(&self) -> Result<i64, ConversionError>

pub fn set_encoded_security_desc_len(&mut self, v: i64)

pub fn has_encoded_security_desc_len(&self) -> bool

pub fn encoded_security_desc(&self) -> Result<Vec<u8>, ConversionError>

pub fn set_encoded_security_desc(&mut self, v: impl Into<Vec<u8>>)

pub fn has_encoded_security_desc(&self) -> bool

pub fn pool(&self) -> Result<String, ConversionError>

pub fn set_pool(&mut self, v: impl Into<String>)

pub fn has_pool(&self) -> bool

pub fn contract_settl_month(&self) -> Result<String, ConversionError>

pub fn set_contract_settl_month(&mut self, v: impl Into<String>)

pub fn has_contract_settl_month(&self) -> bool

pub fn cp_program(&self) -> Result<i64, ConversionError>

pub fn set_cp_program(&mut self, v: i64)

pub fn has_cp_program(&self) -> bool

pub fn cp_reg_type(&self) -> Result<String, ConversionError>

pub fn set_cp_reg_type(&mut self, v: impl Into<String>)

pub fn has_cp_reg_type(&self) -> bool

pub fn no_events(&self) -> Result<Vec<NoEvents>, ConversionError>

pub fn set_no_events(&mut self, groups: impl IntoIterator<Item = NoEvents>)

pub fn dated_date(&self) -> Result<FixDate, ConversionError>

pub fn set_dated_date(&mut self, v: FixDate)

pub fn has_dated_date(&self) -> bool

pub fn interest_accrual_date(&self) -> Result<FixDate, ConversionError>

pub fn set_interest_accrual_date(&mut self, v: FixDate)

pub fn has_interest_accrual_date(&self) -> bool

pub fn agreement_desc(&self) -> Result<String, ConversionError>

pub fn set_agreement_desc(&mut self, v: impl Into<String>)

pub fn has_agreement_desc(&self) -> bool

pub fn agreement_id(&self) -> Result<String, ConversionError>

pub fn set_agreement_id(&mut self, v: impl Into<String>)

pub fn has_agreement_id(&self) -> bool

pub fn agreement_date(&self) -> Result<FixDate, ConversionError>

pub fn set_agreement_date(&mut self, v: FixDate)

pub fn has_agreement_date(&self) -> bool

pub fn agreement_currency(&self) -> Result<String, ConversionError>

pub fn set_agreement_currency(&mut self, v: impl Into<String>)

pub fn has_agreement_currency(&self) -> bool

pub fn termination_type(&self) -> Result<i64, ConversionError>

pub fn set_termination_type(&mut self, v: i64)

pub fn has_termination_type(&self) -> bool

pub fn start_date(&self) -> Result<FixDate, ConversionError>

pub fn set_start_date(&mut self, v: FixDate)

pub fn has_start_date(&self) -> bool

pub fn end_date(&self) -> Result<FixDate, ConversionError>

pub fn set_end_date(&mut self, v: FixDate)

pub fn has_end_date(&self) -> bool

pub fn delivery_type(&self) -> Result<i64, ConversionError>

pub fn set_delivery_type(&mut self, v: i64)

pub fn has_delivery_type(&self) -> bool

pub fn margin_ratio(&self) -> Result<Amount, ConversionError>

pub fn set_margin_ratio(&mut self, v: Amount)

pub fn has_margin_ratio(&self) -> bool

pub fn no_underlyings(&self) -> Result<Vec<NoUnderlyings>, ConversionError>

pub fn set_no_underlyings( &mut self, groups: impl IntoIterator<Item = NoUnderlyings>, )

pub fn side(&self) -> Result<char, ConversionError>

pub fn set_side(&mut self, v: char)

pub fn has_side(&self) -> bool

pub fn no_stipulations(&self) -> Result<Vec<NoStipulations>, ConversionError>

pub fn set_no_stipulations( &mut self, groups: impl IntoIterator<Item = NoStipulations>, )

pub fn qty_type(&self) -> Result<i64, ConversionError>

pub fn set_qty_type(&mut self, v: i64)

pub fn has_qty_type(&self) -> bool

pub fn order_qty(&self) -> Result<Amount, ConversionError>

pub fn set_order_qty(&mut self, v: Amount)

pub fn has_order_qty(&self) -> bool

pub fn cash_order_qty(&self) -> Result<Amount, ConversionError>

pub fn set_cash_order_qty(&mut self, v: Amount)

pub fn has_cash_order_qty(&self) -> bool

pub fn order_percent(&self) -> Result<Amount, ConversionError>

pub fn set_order_percent(&mut self, v: Amount)

pub fn has_order_percent(&self) -> bool

pub fn rounding_direction(&self) -> Result<char, ConversionError>

pub fn set_rounding_direction(&mut self, v: char)

pub fn has_rounding_direction(&self) -> bool

pub fn rounding_modulus(&self) -> Result<Amount, ConversionError>

pub fn set_rounding_modulus(&mut self, v: Amount)

pub fn has_rounding_modulus(&self) -> bool

pub fn ord_type(&self) -> Result<char, ConversionError>

pub fn set_ord_type(&mut self, v: char)

pub fn has_ord_type(&self) -> bool

pub fn price_type(&self) -> Result<i64, ConversionError>

pub fn set_price_type(&mut self, v: i64)

pub fn has_price_type(&self) -> bool

pub fn price(&self) -> Result<Amount, ConversionError>

pub fn set_price(&mut self, v: Amount)

pub fn has_price(&self) -> bool

pub fn stop_px(&self) -> Result<Amount, ConversionError>

pub fn set_stop_px(&mut self, v: Amount)

pub fn has_stop_px(&self) -> bool

pub fn peg_offset_value(&self) -> Result<Amount, ConversionError>

pub fn set_peg_offset_value(&mut self, v: Amount)

pub fn has_peg_offset_value(&self) -> bool

pub fn peg_move_type(&self) -> Result<i64, ConversionError>

pub fn set_peg_move_type(&mut self, v: i64)

pub fn has_peg_move_type(&self) -> bool

pub fn peg_offset_type(&self) -> Result<i64, ConversionError>

pub fn set_peg_offset_type(&mut self, v: i64)

pub fn has_peg_offset_type(&self) -> bool

pub fn peg_limit_type(&self) -> Result<i64, ConversionError>

pub fn set_peg_limit_type(&mut self, v: i64)

pub fn has_peg_limit_type(&self) -> bool

pub fn peg_round_direction(&self) -> Result<i64, ConversionError>

pub fn set_peg_round_direction(&mut self, v: i64)

pub fn has_peg_round_direction(&self) -> bool

pub fn peg_scope(&self) -> Result<i64, ConversionError>

pub fn set_peg_scope(&mut self, v: i64)

pub fn has_peg_scope(&self) -> bool

pub fn discretion_inst(&self) -> Result<char, ConversionError>

pub fn set_discretion_inst(&mut self, v: char)

pub fn has_discretion_inst(&self) -> bool

pub fn discretion_offset_value(&self) -> Result<Amount, ConversionError>

pub fn set_discretion_offset_value(&mut self, v: Amount)

pub fn has_discretion_offset_value(&self) -> bool

pub fn discretion_move_type(&self) -> Result<i64, ConversionError>

pub fn set_discretion_move_type(&mut self, v: i64)

pub fn has_discretion_move_type(&self) -> bool

pub fn discretion_offset_type(&self) -> Result<i64, ConversionError>

pub fn set_discretion_offset_type(&mut self, v: i64)

pub fn has_discretion_offset_type(&self) -> bool

pub fn discretion_limit_type(&self) -> Result<i64, ConversionError>

pub fn set_discretion_limit_type(&mut self, v: i64)

pub fn has_discretion_limit_type(&self) -> bool

pub fn discretion_round_direction(&self) -> Result<i64, ConversionError>

pub fn set_discretion_round_direction(&mut self, v: i64)

pub fn has_discretion_round_direction(&self) -> bool

pub fn discretion_scope(&self) -> Result<i64, ConversionError>

pub fn set_discretion_scope(&mut self, v: i64)

pub fn has_discretion_scope(&self) -> bool

pub fn pegged_price(&self) -> Result<Amount, ConversionError>

pub fn set_pegged_price(&mut self, v: Amount)

pub fn has_pegged_price(&self) -> bool

pub fn discretion_price(&self) -> Result<Amount, ConversionError>

pub fn set_discretion_price(&mut self, v: Amount)

pub fn has_discretion_price(&self) -> bool

pub fn target_strategy(&self) -> Result<i64, ConversionError>

pub fn set_target_strategy(&mut self, v: i64)

pub fn has_target_strategy(&self) -> bool

pub fn target_strategy_parameters(&self) -> Result<String, ConversionError>

pub fn set_target_strategy_parameters(&mut self, v: impl Into<String>)

pub fn has_target_strategy_parameters(&self) -> bool

pub fn participation_rate(&self) -> Result<Amount, ConversionError>

pub fn set_participation_rate(&mut self, v: Amount)

pub fn has_participation_rate(&self) -> bool

pub fn target_strategy_performance(&self) -> Result<Amount, ConversionError>

pub fn set_target_strategy_performance(&mut self, v: Amount)

pub fn has_target_strategy_performance(&self) -> bool

pub fn currency(&self) -> Result<String, ConversionError>

pub fn set_currency(&mut self, v: impl Into<String>)

pub fn has_currency(&self) -> bool

pub fn compliance_id(&self) -> Result<String, ConversionError>

pub fn set_compliance_id(&mut self, v: impl Into<String>)

pub fn has_compliance_id(&self) -> bool

pub fn solicited_flag(&self) -> Result<bool, ConversionError>

pub fn set_solicited_flag(&mut self, v: bool)

pub fn has_solicited_flag(&self) -> bool

pub fn time_in_force(&self) -> Result<char, ConversionError>

pub fn set_time_in_force(&mut self, v: char)

pub fn has_time_in_force(&self) -> bool

pub fn effective_time(&self) -> Result<UtcTimestamp, ConversionError>

pub fn set_effective_time(&mut self, v: UtcTimestamp)

pub fn has_effective_time(&self) -> bool

pub fn expire_date(&self) -> Result<FixDate, ConversionError>

pub fn set_expire_date(&mut self, v: FixDate)

pub fn has_expire_date(&self) -> bool

pub fn expire_time(&self) -> Result<UtcTimestamp, ConversionError>

pub fn set_expire_time(&mut self, v: UtcTimestamp)

pub fn has_expire_time(&self) -> bool

pub fn exec_inst(&self) -> Result<String, ConversionError>

pub fn set_exec_inst(&mut self, v: impl Into<String>)

pub fn has_exec_inst(&self) -> bool

pub fn order_capacity(&self) -> Result<char, ConversionError>

pub fn set_order_capacity(&mut self, v: char)

pub fn has_order_capacity(&self) -> bool

pub fn order_restrictions(&self) -> Result<String, ConversionError>

pub fn set_order_restrictions(&mut self, v: impl Into<String>)

pub fn has_order_restrictions(&self) -> bool

pub fn cust_order_capacity(&self) -> Result<i64, ConversionError>

pub fn set_cust_order_capacity(&mut self, v: i64)

pub fn has_cust_order_capacity(&self) -> bool

pub fn last_qty(&self) -> Result<Amount, ConversionError>

pub fn set_last_qty(&mut self, v: Amount)

pub fn has_last_qty(&self) -> bool

pub fn underlying_last_qty(&self) -> Result<Amount, ConversionError>

pub fn set_underlying_last_qty(&mut self, v: Amount)

pub fn has_underlying_last_qty(&self) -> bool

pub fn last_px(&self) -> Result<Amount, ConversionError>

pub fn set_last_px(&mut self, v: Amount)

pub fn has_last_px(&self) -> bool

pub fn underlying_last_px(&self) -> Result<Amount, ConversionError>

pub fn set_underlying_last_px(&mut self, v: Amount)

pub fn has_underlying_last_px(&self) -> bool

pub fn last_par_px(&self) -> Result<Amount, ConversionError>

pub fn set_last_par_px(&mut self, v: Amount)

pub fn has_last_par_px(&self) -> bool

pub fn last_spot_rate(&self) -> Result<Amount, ConversionError>

pub fn set_last_spot_rate(&mut self, v: Amount)

pub fn has_last_spot_rate(&self) -> bool

pub fn last_forward_points(&self) -> Result<Amount, ConversionError>

pub fn set_last_forward_points(&mut self, v: Amount)

pub fn has_last_forward_points(&self) -> bool

pub fn last_mkt(&self) -> Result<String, ConversionError>

pub fn set_last_mkt(&mut self, v: impl Into<String>)

pub fn has_last_mkt(&self) -> bool

pub fn trading_session_id(&self) -> Result<String, ConversionError>

pub fn set_trading_session_id(&mut self, v: impl Into<String>)

pub fn has_trading_session_id(&self) -> bool

pub fn trading_session_sub_id(&self) -> Result<String, ConversionError>

pub fn set_trading_session_sub_id(&mut self, v: impl Into<String>)

pub fn has_trading_session_sub_id(&self) -> bool

pub fn time_bracket(&self) -> Result<String, ConversionError>

pub fn set_time_bracket(&mut self, v: impl Into<String>)

pub fn has_time_bracket(&self) -> bool

pub fn last_capacity(&self) -> Result<char, ConversionError>

pub fn set_last_capacity(&mut self, v: char)

pub fn has_last_capacity(&self) -> bool

pub fn leaves_qty(&self) -> Result<Amount, ConversionError>

pub fn set_leaves_qty(&mut self, v: Amount)

pub fn has_leaves_qty(&self) -> bool

pub fn cum_qty(&self) -> Result<Amount, ConversionError>

pub fn set_cum_qty(&mut self, v: Amount)

pub fn has_cum_qty(&self) -> bool

pub fn avg_px(&self) -> Result<Amount, ConversionError>

pub fn set_avg_px(&mut self, v: Amount)

pub fn has_avg_px(&self) -> bool

pub fn day_order_qty(&self) -> Result<Amount, ConversionError>

pub fn set_day_order_qty(&mut self, v: Amount)

pub fn has_day_order_qty(&self) -> bool

pub fn day_cum_qty(&self) -> Result<Amount, ConversionError>

pub fn set_day_cum_qty(&mut self, v: Amount)

pub fn has_day_cum_qty(&self) -> bool

pub fn day_avg_px(&self) -> Result<Amount, ConversionError>

pub fn set_day_avg_px(&mut self, v: Amount)

pub fn has_day_avg_px(&self) -> bool

pub fn gt_booking_inst(&self) -> Result<i64, ConversionError>

pub fn set_gt_booking_inst(&mut self, v: i64)

pub fn has_gt_booking_inst(&self) -> bool

pub fn trade_date(&self) -> Result<FixDate, ConversionError>

pub fn set_trade_date(&mut self, v: FixDate)

pub fn has_trade_date(&self) -> bool

pub fn transact_time(&self) -> Result<UtcTimestamp, ConversionError>

pub fn set_transact_time(&mut self, v: UtcTimestamp)

pub fn has_transact_time(&self) -> bool

pub fn report_to_exch(&self) -> Result<bool, ConversionError>

pub fn set_report_to_exch(&mut self, v: bool)

pub fn has_report_to_exch(&self) -> bool

pub fn commission(&self) -> Result<Amount, ConversionError>

pub fn set_commission(&mut self, v: Amount)

pub fn has_commission(&self) -> bool

pub fn comm_type(&self) -> Result<char, ConversionError>

pub fn set_comm_type(&mut self, v: char)

pub fn has_comm_type(&self) -> bool

pub fn comm_currency(&self) -> Result<String, ConversionError>

pub fn set_comm_currency(&mut self, v: impl Into<String>)

pub fn has_comm_currency(&self) -> bool

pub fn fund_renew_waiv(&self) -> Result<char, ConversionError>

pub fn set_fund_renew_waiv(&mut self, v: char)

pub fn has_fund_renew_waiv(&self) -> bool

pub fn spread(&self) -> Result<Amount, ConversionError>

pub fn set_spread(&mut self, v: Amount)

pub fn has_spread(&self) -> bool

pub fn benchmark_curve_currency(&self) -> Result<String, ConversionError>

pub fn set_benchmark_curve_currency(&mut self, v: impl Into<String>)

pub fn has_benchmark_curve_currency(&self) -> bool

pub fn benchmark_curve_name(&self) -> Result<String, ConversionError>

pub fn set_benchmark_curve_name(&mut self, v: impl Into<String>)

pub fn has_benchmark_curve_name(&self) -> bool

pub fn benchmark_curve_point(&self) -> Result<String, ConversionError>

pub fn set_benchmark_curve_point(&mut self, v: impl Into<String>)

pub fn has_benchmark_curve_point(&self) -> bool

pub fn benchmark_price(&self) -> Result<Amount, ConversionError>

pub fn set_benchmark_price(&mut self, v: Amount)

pub fn has_benchmark_price(&self) -> bool

pub fn benchmark_price_type(&self) -> Result<i64, ConversionError>

pub fn set_benchmark_price_type(&mut self, v: i64)

pub fn has_benchmark_price_type(&self) -> bool

pub fn benchmark_security_id(&self) -> Result<String, ConversionError>

pub fn set_benchmark_security_id(&mut self, v: impl Into<String>)

pub fn has_benchmark_security_id(&self) -> bool

pub fn benchmark_security_id_source(&self) -> Result<String, ConversionError>

pub fn set_benchmark_security_id_source(&mut self, v: impl Into<String>)

pub fn has_benchmark_security_id_source(&self) -> bool

pub fn yield_type(&self) -> Result<String, ConversionError>

pub fn set_yield_type(&mut self, v: impl Into<String>)

pub fn has_yield_type(&self) -> bool

pub fn yield_(&self) -> Result<Amount, ConversionError>

pub fn set_yield_(&mut self, v: Amount)

pub fn has_yield_(&self) -> bool

pub fn yield_calc_date(&self) -> Result<FixDate, ConversionError>

pub fn set_yield_calc_date(&mut self, v: FixDate)

pub fn has_yield_calc_date(&self) -> bool

pub fn yield_redemption_date(&self) -> Result<FixDate, ConversionError>

pub fn set_yield_redemption_date(&mut self, v: FixDate)

pub fn has_yield_redemption_date(&self) -> bool

pub fn yield_redemption_price(&self) -> Result<Amount, ConversionError>

pub fn set_yield_redemption_price(&mut self, v: Amount)

pub fn has_yield_redemption_price(&self) -> bool

pub fn yield_redemption_price_type(&self) -> Result<i64, ConversionError>

pub fn set_yield_redemption_price_type(&mut self, v: i64)

pub fn has_yield_redemption_price_type(&self) -> bool

pub fn gross_trade_amt(&self) -> Result<Amount, ConversionError>

pub fn set_gross_trade_amt(&mut self, v: Amount)

pub fn has_gross_trade_amt(&self) -> bool

pub fn num_days_interest(&self) -> Result<i64, ConversionError>

pub fn set_num_days_interest(&mut self, v: i64)

pub fn has_num_days_interest(&self) -> bool

pub fn ex_date(&self) -> Result<FixDate, ConversionError>

pub fn set_ex_date(&mut self, v: FixDate)

pub fn has_ex_date(&self) -> bool

pub fn accrued_interest_rate(&self) -> Result<Amount, ConversionError>

pub fn set_accrued_interest_rate(&mut self, v: Amount)

pub fn has_accrued_interest_rate(&self) -> bool

pub fn accrued_interest_amt(&self) -> Result<Amount, ConversionError>

pub fn set_accrued_interest_amt(&mut self, v: Amount)

pub fn has_accrued_interest_amt(&self) -> bool

pub fn interest_at_maturity(&self) -> Result<Amount, ConversionError>

pub fn set_interest_at_maturity(&mut self, v: Amount)

pub fn has_interest_at_maturity(&self) -> bool

pub fn end_accrued_interest_amt(&self) -> Result<Amount, ConversionError>

pub fn set_end_accrued_interest_amt(&mut self, v: Amount)

pub fn has_end_accrued_interest_amt(&self) -> bool

pub fn start_cash(&self) -> Result<Amount, ConversionError>

pub fn set_start_cash(&mut self, v: Amount)

pub fn has_start_cash(&self) -> bool

pub fn end_cash(&self) -> Result<Amount, ConversionError>

pub fn set_end_cash(&mut self, v: Amount)

pub fn has_end_cash(&self) -> bool

pub fn traded_flat_switch(&self) -> Result<bool, ConversionError>

pub fn set_traded_flat_switch(&mut self, v: bool)

pub fn has_traded_flat_switch(&self) -> bool

pub fn basis_feature_date(&self) -> Result<FixDate, ConversionError>

pub fn set_basis_feature_date(&mut self, v: FixDate)

pub fn has_basis_feature_date(&self) -> bool

pub fn basis_feature_price(&self) -> Result<Amount, ConversionError>

pub fn set_basis_feature_price(&mut self, v: Amount)

pub fn has_basis_feature_price(&self) -> bool

pub fn concession(&self) -> Result<Amount, ConversionError>

pub fn set_concession(&mut self, v: Amount)

pub fn has_concession(&self) -> bool

pub fn total_takedown(&self) -> Result<Amount, ConversionError>

pub fn set_total_takedown(&mut self, v: Amount)

pub fn has_total_takedown(&self) -> bool

pub fn net_money(&self) -> Result<Amount, ConversionError>

pub fn set_net_money(&mut self, v: Amount)

pub fn has_net_money(&self) -> bool

pub fn settl_curr_amt(&self) -> Result<Amount, ConversionError>

pub fn set_settl_curr_amt(&mut self, v: Amount)

pub fn has_settl_curr_amt(&self) -> bool

pub fn settl_currency(&self) -> Result<String, ConversionError>

pub fn set_settl_currency(&mut self, v: impl Into<String>)

pub fn has_settl_currency(&self) -> bool

pub fn settl_curr_fx_rate(&self) -> Result<Amount, ConversionError>

pub fn set_settl_curr_fx_rate(&mut self, v: Amount)

pub fn has_settl_curr_fx_rate(&self) -> bool

pub fn settl_curr_fx_rate_calc(&self) -> Result<char, ConversionError>

pub fn set_settl_curr_fx_rate_calc(&mut self, v: char)

pub fn has_settl_curr_fx_rate_calc(&self) -> bool

pub fn handl_inst(&self) -> Result<char, ConversionError>

pub fn set_handl_inst(&mut self, v: char)

pub fn has_handl_inst(&self) -> bool

pub fn min_qty(&self) -> Result<Amount, ConversionError>

pub fn set_min_qty(&mut self, v: Amount)

pub fn has_min_qty(&self) -> bool

pub fn max_floor(&self) -> Result<Amount, ConversionError>

pub fn set_max_floor(&mut self, v: Amount)

pub fn has_max_floor(&self) -> bool

pub fn position_effect(&self) -> Result<char, ConversionError>

pub fn set_position_effect(&mut self, v: char)

pub fn has_position_effect(&self) -> bool

pub fn max_show(&self) -> Result<Amount, ConversionError>

pub fn set_max_show(&mut self, v: Amount)

pub fn has_max_show(&self) -> bool

pub fn booking_type(&self) -> Result<i64, ConversionError>

pub fn set_booking_type(&mut self, v: i64)

pub fn has_booking_type(&self) -> bool

pub fn text(&self) -> Result<String, ConversionError>

pub fn set_text(&mut self, v: impl Into<String>)

pub fn has_text(&self) -> bool

pub fn encoded_text_len(&self) -> Result<i64, ConversionError>

pub fn set_encoded_text_len(&mut self, v: i64)

pub fn has_encoded_text_len(&self) -> bool

pub fn encoded_text(&self) -> Result<Vec<u8>, ConversionError>

pub fn set_encoded_text(&mut self, v: impl Into<Vec<u8>>)

pub fn has_encoded_text(&self) -> bool

pub fn settl_date2(&self) -> Result<FixDate, ConversionError>

pub fn set_settl_date2(&mut self, v: FixDate)

pub fn has_settl_date2(&self) -> bool

pub fn order_qty2(&self) -> Result<Amount, ConversionError>

pub fn set_order_qty2(&mut self, v: Amount)

pub fn has_order_qty2(&self) -> bool

pub fn last_forward_points2(&self) -> Result<Amount, ConversionError>

pub fn set_last_forward_points2(&mut self, v: Amount)

pub fn has_last_forward_points2(&self) -> bool

pub fn multi_leg_reporting_type(&self) -> Result<char, ConversionError>

pub fn set_multi_leg_reporting_type(&mut self, v: char)

pub fn has_multi_leg_reporting_type(&self) -> bool

pub fn cancellation_rights(&self) -> Result<char, ConversionError>

pub fn set_cancellation_rights(&mut self, v: char)

pub fn has_cancellation_rights(&self) -> bool

pub fn money_laundering_status(&self) -> Result<char, ConversionError>

pub fn set_money_laundering_status(&mut self, v: char)

pub fn has_money_laundering_status(&self) -> bool

pub fn regist_id(&self) -> Result<String, ConversionError>

pub fn set_regist_id(&mut self, v: impl Into<String>)

pub fn has_regist_id(&self) -> bool

pub fn designation(&self) -> Result<String, ConversionError>

pub fn set_designation(&mut self, v: impl Into<String>)

pub fn has_designation(&self) -> bool

pub fn trans_bkd_time(&self) -> Result<UtcTimestamp, ConversionError>

pub fn set_trans_bkd_time(&mut self, v: UtcTimestamp)

pub fn has_trans_bkd_time(&self) -> bool

pub fn exec_valuation_point(&self) -> Result<UtcTimestamp, ConversionError>

pub fn set_exec_valuation_point(&mut self, v: UtcTimestamp)

pub fn has_exec_valuation_point(&self) -> bool

pub fn exec_price_type(&self) -> Result<char, ConversionError>

pub fn set_exec_price_type(&mut self, v: char)

pub fn has_exec_price_type(&self) -> bool

pub fn exec_price_adjustment(&self) -> Result<Amount, ConversionError>

pub fn set_exec_price_adjustment(&mut self, v: Amount)

pub fn has_exec_price_adjustment(&self) -> bool

pub fn priority_indicator(&self) -> Result<i64, ConversionError>

pub fn set_priority_indicator(&mut self, v: i64)

pub fn has_priority_indicator(&self) -> bool

pub fn price_improvement(&self) -> Result<Amount, ConversionError>

pub fn set_price_improvement(&mut self, v: Amount)

pub fn has_price_improvement(&self) -> bool

pub fn last_liquidity_ind(&self) -> Result<i64, ConversionError>

pub fn set_last_liquidity_ind(&mut self, v: i64)

pub fn has_last_liquidity_ind(&self) -> bool

pub fn no_cont_amts(&self) -> Result<Vec<NoContAmts>, ConversionError>

pub fn set_no_cont_amts(&mut self, groups: impl IntoIterator<Item = NoContAmts>)

pub fn no_legs(&self) -> Result<Vec<NoLegs>, ConversionError>

pub fn set_no_legs(&mut self, groups: impl IntoIterator<Item = NoLegs>)

pub fn copy_msg_indicator(&self) -> Result<bool, ConversionError>

pub fn set_copy_msg_indicator(&mut self, v: bool)

pub fn has_copy_msg_indicator(&self) -> bool

pub fn no_misc_fees(&self) -> Result<Vec<NoMiscFees>, ConversionError>

pub fn set_no_misc_fees(&mut self, groups: impl IntoIterator<Item = NoMiscFees>)

Methods from Deref<Target = Message>

pub fn msg_type(&self) -> Result<String>

pub fn is_admin(&self) -> bool

pub fn seq_num(&self) -> Result<u64>

pub fn poss_dup(&self) -> bool

pub fn structure_error(&self) -> Option<Tag>

First tag found out of section order during parse, if any.

pub fn to_bytes(&self) -> Vec<u8>

Serialize, computing BodyLength(9) and CheckSum(10).

Header order matches the reference engines: 8, 9, 35, then remaining header fields in ascending tag order. Body keeps insertion (wire) order. Trailer: descending tag order (SignatureLength before Signature), CheckSum last.

pub fn set_header(&mut self, tag: Tag, value: impl FixEncode)

Set a header field (helper).

pub fn set(&mut self, tag: Tag, value: impl FixEncode)

Set a body field (helper).

pub fn stamp_sending_time(&mut self, ts: UtcTimestamp)

Stamp SendingTime(52) with now at the given precision.

Trait Implementations

impl Clone for ExecutionReport

fn clone(&self) -> ExecutionReport

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExecutionReport

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for ExecutionReport

type Target = Message

The resulting type after dereferencing.

fn deref(&self) -> &Message

Dereferences the value.

impl DerefMut for ExecutionReport

fn deref_mut(&mut self) -> &mut Message

Mutably dereferences the value.

impl From<ExecutionReport> for Message

fn from(m: ExecutionReport) -> Message

Converts to this type from the input type.