fixer-fix 0.10.1

// Code generated by fixer-gen. DO NOT EDIT.
#![allow(clippy::new_without_default)]
#![allow(clippy::needless_pass_by_value)]
#![allow(clippy::too_many_arguments)]
#![allow(unused_imports)]

use fixer::message::Message;
use fixer::fix_string::FIXString;
use fixer::errors::MessageRejectErrorEnum;
use fixer::session::session_id::SessionID;

use rust_decimal::Decimal;


use jiff::Timestamp;

use crate::field;
use crate::tag;

/// `MarketDefinition` is the `fix50sp2` `MarketDefinition` type, `MsgType` = BU.
pub struct MarketDefinition {
    pub message: Message,
}

impl MarketDefinition {
    /// Creates a new `MarketDefinition` with required fields.
    pub fn new(market_report_id: field::MarketReportIDField, market_id: field::MarketIDField) -> Self {
        let mut msg = Message::new();
        msg.header.set_field(tag::MSG_TYPE, FIXString::from("BU".to_string()));

        msg.body.set_field(tag::MARKET_REPORT_ID, market_report_id.0);

        msg.body.set_field(tag::MARKET_ID, market_id.0);

        Self { message: msg }
    }

    /// Creates a `MarketDefinition` from an existing `Message`.
    pub fn from_message(msg: Message) -> Self {
        Self { message: msg }
    }

    /// Returns the underlying `Message`.
    pub fn to_message(self) -> Message {
        self.message
    }




    /// Sets `ApplID`, Tag 1180.
    pub fn set_appl_id(&mut self, v: String) {
        self.message.body.set_field(tag::APPL_ID, FIXString::from(v));
    }

    /// Gets `ApplID`, Tag 1180.
    pub fn get_appl_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::ApplIDField::new(String::new());
        self.message.body.get_field(tag::APPL_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `ApplID` is present, Tag 1180.
    pub fn has_appl_id(&self) -> bool {
        self.message.body.has(tag::APPL_ID)
    }




    /// Sets `ApplLastSeqNum`, Tag 1350.
    pub fn set_appl_last_seq_num(&mut self, v: isize) {
        self.message.body.set_field(tag::APPL_LAST_SEQ_NUM, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `ApplLastSeqNum`, Tag 1350.
    pub fn get_appl_last_seq_num(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::ApplLastSeqNumField::new(0);
        self.message.body.get_field(tag::APPL_LAST_SEQ_NUM, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ApplLastSeqNum` is present, Tag 1350.
    pub fn has_appl_last_seq_num(&self) -> bool {
        self.message.body.has(tag::APPL_LAST_SEQ_NUM)
    }




    /// Sets `ApplResendFlag`, Tag 1352.
    pub fn set_appl_resend_flag(&mut self, v: bool) {
        self.message.body.set_field(tag::APPL_RESEND_FLAG, fixer::fix_boolean::FIXBoolean::from(v));
    }

    /// Gets `ApplResendFlag`, Tag 1352.
    pub fn get_appl_resend_flag(&self) -> Result<bool, MessageRejectErrorEnum> {
        let mut fld = field::ApplResendFlagField::new(false);
        self.message.body.get_field(tag::APPL_RESEND_FLAG, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ApplResendFlag` is present, Tag 1352.
    pub fn has_appl_resend_flag(&self) -> bool {
        self.message.body.has(tag::APPL_RESEND_FLAG)
    }




    /// Sets `ApplSeqNum`, Tag 1181.
    pub fn set_appl_seq_num(&mut self, v: isize) {
        self.message.body.set_field(tag::APPL_SEQ_NUM, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `ApplSeqNum`, Tag 1181.
    pub fn get_appl_seq_num(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::ApplSeqNumField::new(0);
        self.message.body.get_field(tag::APPL_SEQ_NUM, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ApplSeqNum` is present, Tag 1181.
    pub fn has_appl_seq_num(&self) -> bool {
        self.message.body.has(tag::APPL_SEQ_NUM)
    }




    /// Sets `Currency`, Tag 15.
    pub fn set_currency(&mut self, v: String) {
        self.message.body.set_field(tag::CURRENCY, FIXString::from(v));
    }

    /// Gets `Currency`, Tag 15.
    pub fn get_currency(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::CurrencyField::new(String::new());
        self.message.body.get_field(tag::CURRENCY, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `Currency` is present, Tag 15.
    pub fn has_currency(&self) -> bool {
        self.message.body.has(tag::CURRENCY)
    }




    /// Sets `EncodedMktSegmDesc`, Tag 1398.
    pub fn set_encoded_mkt_segm_desc(&mut self, v: String) {
        self.message.body.set_field(tag::ENCODED_MKT_SEGM_DESC, FIXString::from(v));
    }

    /// Gets `EncodedMktSegmDesc`, Tag 1398.
    pub fn get_encoded_mkt_segm_desc(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::EncodedMktSegmDescField::new(String::new());
        self.message.body.get_field(tag::ENCODED_MKT_SEGM_DESC, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `EncodedMktSegmDesc` is present, Tag 1398.
    pub fn has_encoded_mkt_segm_desc(&self) -> bool {
        self.message.body.has(tag::ENCODED_MKT_SEGM_DESC)
    }




    /// Sets `EncodedMktSegmDescLen`, Tag 1397.
    pub fn set_encoded_mkt_segm_desc_len(&mut self, v: isize) {
        self.message.body.set_field(tag::ENCODED_MKT_SEGM_DESC_LEN, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `EncodedMktSegmDescLen`, Tag 1397.
    pub fn get_encoded_mkt_segm_desc_len(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::EncodedMktSegmDescLenField::new(0);
        self.message.body.get_field(tag::ENCODED_MKT_SEGM_DESC_LEN, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `EncodedMktSegmDescLen` is present, Tag 1397.
    pub fn has_encoded_mkt_segm_desc_len(&self) -> bool {
        self.message.body.has(tag::ENCODED_MKT_SEGM_DESC_LEN)
    }




    /// Sets `EncodedText`, Tag 355.
    pub fn set_encoded_text(&mut self, v: String) {
        self.message.body.set_field(tag::ENCODED_TEXT, FIXString::from(v));
    }

    /// Gets `EncodedText`, Tag 355.
    pub fn get_encoded_text(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::EncodedTextField::new(String::new());
        self.message.body.get_field(tag::ENCODED_TEXT, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `EncodedText` is present, Tag 355.
    pub fn has_encoded_text(&self) -> bool {
        self.message.body.has(tag::ENCODED_TEXT)
    }




    /// Sets `EncodedTextLen`, Tag 354.
    pub fn set_encoded_text_len(&mut self, v: isize) {
        self.message.body.set_field(tag::ENCODED_TEXT_LEN, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `EncodedTextLen`, Tag 354.
    pub fn get_encoded_text_len(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::EncodedTextLenField::new(0);
        self.message.body.get_field(tag::ENCODED_TEXT_LEN, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `EncodedTextLen` is present, Tag 354.
    pub fn has_encoded_text_len(&self) -> bool {
        self.message.body.has(tag::ENCODED_TEXT_LEN)
    }




    /// Sets `ExpirationCycle`, Tag 827.
    pub fn set_expiration_cycle(&mut self, v: isize) {
        self.message.body.set_field(tag::EXPIRATION_CYCLE, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `ExpirationCycle`, Tag 827.
    pub fn get_expiration_cycle(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::ExpirationCycleField::new(0);
        self.message.body.get_field(tag::EXPIRATION_CYCLE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ExpirationCycle` is present, Tag 827.
    pub fn has_expiration_cycle(&self) -> bool {
        self.message.body.has(tag::EXPIRATION_CYCLE)
    }




    /// Sets `HighLimitPrice`, Tag 1149.
    pub fn set_high_limit_price(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::HIGH_LIMIT_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `HighLimitPrice`, Tag 1149.
    pub fn get_high_limit_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::HighLimitPriceField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::HIGH_LIMIT_PRICE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `HighLimitPrice` is present, Tag 1149.
    pub fn has_high_limit_price(&self) -> bool {
        self.message.body.has(tag::HIGH_LIMIT_PRICE)
    }




    /// Sets `ImpliedMarketIndicator`, Tag 1144.
    pub fn set_implied_market_indicator(&mut self, v: isize) {
        self.message.body.set_field(tag::IMPLIED_MARKET_INDICATOR, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `ImpliedMarketIndicator`, Tag 1144.
    pub fn get_implied_market_indicator(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::ImpliedMarketIndicatorField::new(0);
        self.message.body.get_field(tag::IMPLIED_MARKET_INDICATOR, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ImpliedMarketIndicator` is present, Tag 1144.
    pub fn has_implied_market_indicator(&self) -> bool {
        self.message.body.has(tag::IMPLIED_MARKET_INDICATOR)
    }




    /// Sets `LowLimitPrice`, Tag 1148.
    pub fn set_low_limit_price(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::LOW_LIMIT_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `LowLimitPrice`, Tag 1148.
    pub fn get_low_limit_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::LowLimitPriceField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::LOW_LIMIT_PRICE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `LowLimitPrice` is present, Tag 1148.
    pub fn has_low_limit_price(&self) -> bool {
        self.message.body.has(tag::LOW_LIMIT_PRICE)
    }




    /// Sets `MarketID`, Tag 1301.
    pub fn set_market_id(&mut self, v: String) {
        self.message.body.set_field(tag::MARKET_ID, FIXString::from(v));
    }

    /// Gets `MarketID`, Tag 1301.
    pub fn get_market_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::MarketIDField::new(String::new());
        self.message.body.get_field(tag::MARKET_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `MarketID` is present, Tag 1301.
    pub fn has_market_id(&self) -> bool {
        self.message.body.has(tag::MARKET_ID)
    }




    /// Sets `MarketReportID`, Tag 1394.
    pub fn set_market_report_id(&mut self, v: String) {
        self.message.body.set_field(tag::MARKET_REPORT_ID, FIXString::from(v));
    }

    /// Gets `MarketReportID`, Tag 1394.
    pub fn get_market_report_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::MarketReportIDField::new(String::new());
        self.message.body.get_field(tag::MARKET_REPORT_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `MarketReportID` is present, Tag 1394.
    pub fn has_market_report_id(&self) -> bool {
        self.message.body.has(tag::MARKET_REPORT_ID)
    }




    /// Sets `MarketReqID`, Tag 1393.
    pub fn set_market_req_id(&mut self, v: String) {
        self.message.body.set_field(tag::MARKET_REQ_ID, FIXString::from(v));
    }

    /// Gets `MarketReqID`, Tag 1393.
    pub fn get_market_req_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::MarketReqIDField::new(String::new());
        self.message.body.get_field(tag::MARKET_REQ_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `MarketReqID` is present, Tag 1393.
    pub fn has_market_req_id(&self) -> bool {
        self.message.body.has(tag::MARKET_REQ_ID)
    }




    /// Sets `MarketSegmentDesc`, Tag 1396.
    pub fn set_market_segment_desc(&mut self, v: String) {
        self.message.body.set_field(tag::MARKET_SEGMENT_DESC, FIXString::from(v));
    }

    /// Gets `MarketSegmentDesc`, Tag 1396.
    pub fn get_market_segment_desc(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::MarketSegmentDescField::new(String::new());
        self.message.body.get_field(tag::MARKET_SEGMENT_DESC, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `MarketSegmentDesc` is present, Tag 1396.
    pub fn has_market_segment_desc(&self) -> bool {
        self.message.body.has(tag::MARKET_SEGMENT_DESC)
    }




    /// Sets `MarketSegmentID`, Tag 1300.
    pub fn set_market_segment_id(&mut self, v: String) {
        self.message.body.set_field(tag::MARKET_SEGMENT_ID, FIXString::from(v));
    }

    /// Gets `MarketSegmentID`, Tag 1300.
    pub fn get_market_segment_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::MarketSegmentIDField::new(String::new());
        self.message.body.get_field(tag::MARKET_SEGMENT_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `MarketSegmentID` is present, Tag 1300.
    pub fn has_market_segment_id(&self) -> bool {
        self.message.body.has(tag::MARKET_SEGMENT_ID)
    }




    /// Sets `MaxPriceVariation`, Tag 1143.
    pub fn set_max_price_variation(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::MAX_PRICE_VARIATION, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `MaxPriceVariation`, Tag 1143.
    pub fn get_max_price_variation(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::MaxPriceVariationField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::MAX_PRICE_VARIATION, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `MaxPriceVariation` is present, Tag 1143.
    pub fn has_max_price_variation(&self) -> bool {
        self.message.body.has(tag::MAX_PRICE_VARIATION)
    }




    /// Sets `MaxTradeVol`, Tag 1140.
    pub fn set_max_trade_vol(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::MAX_TRADE_VOL, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `MaxTradeVol`, Tag 1140.
    pub fn get_max_trade_vol(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::MaxTradeVolField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::MAX_TRADE_VOL, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `MaxTradeVol` is present, Tag 1140.
    pub fn has_max_trade_vol(&self) -> bool {
        self.message.body.has(tag::MAX_TRADE_VOL)
    }




    /// Sets `MinTradeVol`, Tag 562.
    pub fn set_min_trade_vol(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::MIN_TRADE_VOL, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `MinTradeVol`, Tag 562.
    pub fn get_min_trade_vol(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::MinTradeVolField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::MIN_TRADE_VOL, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `MinTradeVol` is present, Tag 562.
    pub fn has_min_trade_vol(&self) -> bool {
        self.message.body.has(tag::MIN_TRADE_VOL)
    }




    /// Sets `MultilegModel`, Tag 1377.
    pub fn set_multileg_model(&mut self, v: isize) {
        self.message.body.set_field(tag::MULTILEG_MODEL, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `MultilegModel`, Tag 1377.
    pub fn get_multileg_model(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::MultilegModelField::new(0);
        self.message.body.get_field(tag::MULTILEG_MODEL, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `MultilegModel` is present, Tag 1377.
    pub fn has_multileg_model(&self) -> bool {
        self.message.body.has(tag::MULTILEG_MODEL)
    }




    /// Sets `MultilegPriceMethod`, Tag 1378.
    pub fn set_multileg_price_method(&mut self, v: isize) {
        self.message.body.set_field(tag::MULTILEG_PRICE_METHOD, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `MultilegPriceMethod`, Tag 1378.
    pub fn get_multileg_price_method(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::MultilegPriceMethodField::new(0);
        self.message.body.get_field(tag::MULTILEG_PRICE_METHOD, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `MultilegPriceMethod` is present, Tag 1378.
    pub fn has_multileg_price_method(&self) -> bool {
        self.message.body.has(tag::MULTILEG_PRICE_METHOD)
    }




    /// Sets `NoExecInstRules`, Tag 1232.
    pub fn set_no_exec_inst_rules(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_EXEC_INST_RULES, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoExecInstRules`, Tag 1232.
    pub fn get_no_exec_inst_rules(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoExecInstRulesField::new(0);
        self.message.body.get_field(tag::NO_EXEC_INST_RULES, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoExecInstRules` is present, Tag 1232.
    pub fn has_no_exec_inst_rules(&self) -> bool {
        self.message.body.has(tag::NO_EXEC_INST_RULES)
    }




    /// Sets `NoLotTypeRules`, Tag 1234.
    pub fn set_no_lot_type_rules(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_LOT_TYPE_RULES, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoLotTypeRules`, Tag 1234.
    pub fn get_no_lot_type_rules(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoLotTypeRulesField::new(0);
        self.message.body.get_field(tag::NO_LOT_TYPE_RULES, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoLotTypeRules` is present, Tag 1234.
    pub fn has_no_lot_type_rules(&self) -> bool {
        self.message.body.has(tag::NO_LOT_TYPE_RULES)
    }




    /// Sets `NoOrdTypeRules`, Tag 1237.
    pub fn set_no_ord_type_rules(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_ORD_TYPE_RULES, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoOrdTypeRules`, Tag 1237.
    pub fn get_no_ord_type_rules(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoOrdTypeRulesField::new(0);
        self.message.body.get_field(tag::NO_ORD_TYPE_RULES, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoOrdTypeRules` is present, Tag 1237.
    pub fn has_no_ord_type_rules(&self) -> bool {
        self.message.body.has(tag::NO_ORD_TYPE_RULES)
    }




    /// Sets `NoTickRules`, Tag 1205.
    pub fn set_no_tick_rules(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_TICK_RULES, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoTickRules`, Tag 1205.
    pub fn get_no_tick_rules(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoTickRulesField::new(0);
        self.message.body.get_field(tag::NO_TICK_RULES, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoTickRules` is present, Tag 1205.
    pub fn has_no_tick_rules(&self) -> bool {
        self.message.body.has(tag::NO_TICK_RULES)
    }




    /// Sets `NoTimeInForceRules`, Tag 1239.
    pub fn set_no_time_in_force_rules(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_TIME_IN_FORCE_RULES, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoTimeInForceRules`, Tag 1239.
    pub fn get_no_time_in_force_rules(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoTimeInForceRulesField::new(0);
        self.message.body.get_field(tag::NO_TIME_IN_FORCE_RULES, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoTimeInForceRules` is present, Tag 1239.
    pub fn has_no_time_in_force_rules(&self) -> bool {
        self.message.body.has(tag::NO_TIME_IN_FORCE_RULES)
    }




    /// Sets `ParentMktSegmID`, Tag 1325.
    pub fn set_parent_mkt_segm_id(&mut self, v: String) {
        self.message.body.set_field(tag::PARENT_MKT_SEGM_ID, FIXString::from(v));
    }

    /// Gets `ParentMktSegmID`, Tag 1325.
    pub fn get_parent_mkt_segm_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::ParentMktSegmIDField::new(String::new());
        self.message.body.get_field(tag::PARENT_MKT_SEGM_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `ParentMktSegmID` is present, Tag 1325.
    pub fn has_parent_mkt_segm_id(&self) -> bool {
        self.message.body.has(tag::PARENT_MKT_SEGM_ID)
    }




    /// Sets `PriceLimitType`, Tag 1306.
    pub fn set_price_limit_type(&mut self, v: isize) {
        self.message.body.set_field(tag::PRICE_LIMIT_TYPE, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `PriceLimitType`, Tag 1306.
    pub fn get_price_limit_type(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::PriceLimitTypeField::new(0);
        self.message.body.get_field(tag::PRICE_LIMIT_TYPE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `PriceLimitType` is present, Tag 1306.
    pub fn has_price_limit_type(&self) -> bool {
        self.message.body.has(tag::PRICE_LIMIT_TYPE)
    }




    /// Sets `PriceType`, Tag 423.
    pub fn set_price_type(&mut self, v: isize) {
        self.message.body.set_field(tag::PRICE_TYPE, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `PriceType`, Tag 423.
    pub fn get_price_type(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::PriceTypeField::new(0);
        self.message.body.get_field(tag::PRICE_TYPE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `PriceType` is present, Tag 423.
    pub fn has_price_type(&self) -> bool {
        self.message.body.has(tag::PRICE_TYPE)
    }




    /// Sets `RoundLot`, Tag 561.
    pub fn set_round_lot(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::ROUND_LOT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `RoundLot`, Tag 561.
    pub fn get_round_lot(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::RoundLotField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::ROUND_LOT, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `RoundLot` is present, Tag 561.
    pub fn has_round_lot(&self) -> bool {
        self.message.body.has(tag::ROUND_LOT)
    }




    /// Sets `Text`, Tag 58.
    pub fn set_text(&mut self, v: String) {
        self.message.body.set_field(tag::TEXT, FIXString::from(v));
    }

    /// Gets `Text`, Tag 58.
    pub fn get_text(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::TextField::new(String::new());
        self.message.body.get_field(tag::TEXT, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `Text` is present, Tag 58.
    pub fn has_text(&self) -> bool {
        self.message.body.has(tag::TEXT)
    }




    /// Sets `TradingCurrency`, Tag 1245.
    pub fn set_trading_currency(&mut self, v: String) {
        self.message.body.set_field(tag::TRADING_CURRENCY, FIXString::from(v));
    }

    /// Gets `TradingCurrency`, Tag 1245.
    pub fn get_trading_currency(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::TradingCurrencyField::new(String::new());
        self.message.body.get_field(tag::TRADING_CURRENCY, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `TradingCurrency` is present, Tag 1245.
    pub fn has_trading_currency(&self) -> bool {
        self.message.body.has(tag::TRADING_CURRENCY)
    }




    /// Sets `TradingReferencePrice`, Tag 1150.
    pub fn set_trading_reference_price(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::TRADING_REFERENCE_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `TradingReferencePrice`, Tag 1150.
    pub fn get_trading_reference_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::TradingReferencePriceField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::TRADING_REFERENCE_PRICE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `TradingReferencePrice` is present, Tag 1150.
    pub fn has_trading_reference_price(&self) -> bool {
        self.message.body.has(tag::TRADING_REFERENCE_PRICE)
    }




    /// Sets `TransactTime`, Tag 60.
    pub fn set_transact_time(&mut self, v: Timestamp) {
        self.message.body.set_field(tag::TRANSACT_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
            time: v,
            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
        });
    }

    /// Gets `TransactTime`, Tag 60.
    pub fn get_transact_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
        let mut fld = field::TransactTimeField::new(Timestamp::UNIX_EPOCH);
        self.message.body.get_field(tag::TRANSACT_TIME, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `TransactTime` is present, Tag 60.
    pub fn has_transact_time(&self) -> bool {
        self.message.body.has(tag::TRANSACT_TIME)
    }


}

/// `RouteOut` is the callback type for routing `MarketDefinition` messages.
pub type RouteOut = fn(msg: MarketDefinition, session_id: SessionID) -> Result<(), MessageRejectErrorEnum>;

/// Route type returned by the `route` function.
pub type Route = (&'static str, &'static str, Box<dyn Fn(&Message, SessionID) -> Result<(), MessageRejectErrorEnum> + Send>);

/// Returns the begin string, message type, and route function for `MarketDefinition`.
pub fn route(router: RouteOut) -> Route {
    let r = move |msg: &Message, session_id: SessionID| -> Result<(), MessageRejectErrorEnum> {
        router(MarketDefinition::from_message(msg.clone()), session_id)
    };
    ("9", "BU", Box::new(r))
}