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 crate::field;
use crate::tag;

/// `NewOrderList` is the `fix50` `NewOrderList` type, `MsgType` = E.
pub struct NewOrderList {
    pub message: Message,
}

impl NewOrderList {
    /// Creates a new `NewOrderList` with required fields.
    pub fn new(list_id: field::ListIDField, bid_type: field::BidTypeField, tot_no_orders: field::TotNoOrdersField, no_orders: field::NoOrdersField) -> Self {
        let mut msg = Message::new();
        msg.header.set_field(tag::MSG_TYPE, FIXString::from("E".to_string()));

        msg.body.set_field(tag::LIST_ID, list_id.0);

        msg.body.set_field(tag::BID_TYPE, bid_type.0);

        msg.body.set_field(tag::TOT_NO_ORDERS, tot_no_orders.0);

        msg.body.set_field(tag::NO_ORDERS, no_orders.0);

        Self { message: msg }
    }

    /// Creates a `NewOrderList` 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 `AllowableOneSidednessCurr`, Tag 767.
    pub fn set_allowable_one_sidedness_curr(&mut self, v: String) {
        self.message.body.set_field(tag::ALLOWABLE_ONE_SIDEDNESS_CURR, FIXString::from(v));
    }

    /// Gets `AllowableOneSidednessCurr`, Tag 767.
    pub fn get_allowable_one_sidedness_curr(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::AllowableOneSidednessCurrField::new(String::new());
        self.message.body.get_field(tag::ALLOWABLE_ONE_SIDEDNESS_CURR, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `AllowableOneSidednessCurr` is present, Tag 767.
    pub fn has_allowable_one_sidedness_curr(&self) -> bool {
        self.message.body.has(tag::ALLOWABLE_ONE_SIDEDNESS_CURR)
    }




    /// Sets `AllowableOneSidednessPct`, Tag 765.
    pub fn set_allowable_one_sidedness_pct(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::ALLOWABLE_ONE_SIDEDNESS_PCT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `AllowableOneSidednessPct`, Tag 765.
    pub fn get_allowable_one_sidedness_pct(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::AllowableOneSidednessPctField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::ALLOWABLE_ONE_SIDEDNESS_PCT, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `AllowableOneSidednessPct` is present, Tag 765.
    pub fn has_allowable_one_sidedness_pct(&self) -> bool {
        self.message.body.has(tag::ALLOWABLE_ONE_SIDEDNESS_PCT)
    }




    /// Sets `AllowableOneSidednessValue`, Tag 766.
    pub fn set_allowable_one_sidedness_value(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::ALLOWABLE_ONE_SIDEDNESS_VALUE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `AllowableOneSidednessValue`, Tag 766.
    pub fn get_allowable_one_sidedness_value(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::AllowableOneSidednessValueField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::ALLOWABLE_ONE_SIDEDNESS_VALUE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `AllowableOneSidednessValue` is present, Tag 766.
    pub fn has_allowable_one_sidedness_value(&self) -> bool {
        self.message.body.has(tag::ALLOWABLE_ONE_SIDEDNESS_VALUE)
    }




    /// Sets `BidID`, Tag 390.
    pub fn set_bid_id(&mut self, v: String) {
        self.message.body.set_field(tag::BID_ID, FIXString::from(v));
    }

    /// Gets `BidID`, Tag 390.
    pub fn get_bid_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::BidIDField::new(String::new());
        self.message.body.get_field(tag::BID_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `BidID` is present, Tag 390.
    pub fn has_bid_id(&self) -> bool {
        self.message.body.has(tag::BID_ID)
    }




    /// Sets `BidType`, Tag 394.
    pub fn set_bid_type(&mut self, v: isize) {
        self.message.body.set_field(tag::BID_TYPE, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `BidType`, Tag 394.
    pub fn get_bid_type(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::BidTypeField::new(0);
        self.message.body.get_field(tag::BID_TYPE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `BidType` is present, Tag 394.
    pub fn has_bid_type(&self) -> bool {
        self.message.body.has(tag::BID_TYPE)
    }




    /// Sets `CancellationRights`, Tag 480.
    pub fn set_cancellation_rights(&mut self, v: String) {
        self.message.body.set_field(tag::CANCELLATION_RIGHTS, FIXString::from(v));
    }

    /// Gets `CancellationRights`, Tag 480.
    pub fn get_cancellation_rights(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::CancellationRightsField::new(String::new());
        self.message.body.get_field(tag::CANCELLATION_RIGHTS, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `CancellationRights` is present, Tag 480.
    pub fn has_cancellation_rights(&self) -> bool {
        self.message.body.has(tag::CANCELLATION_RIGHTS)
    }




    /// Sets `ClientBidID`, Tag 391.
    pub fn set_client_bid_id(&mut self, v: String) {
        self.message.body.set_field(tag::CLIENT_BID_ID, FIXString::from(v));
    }

    /// Gets `ClientBidID`, Tag 391.
    pub fn get_client_bid_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::ClientBidIDField::new(String::new());
        self.message.body.get_field(tag::CLIENT_BID_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `ClientBidID` is present, Tag 391.
    pub fn has_client_bid_id(&self) -> bool {
        self.message.body.has(tag::CLIENT_BID_ID)
    }




    /// Sets `EncodedListExecInst`, Tag 353.
    pub fn set_encoded_list_exec_inst(&mut self, v: String) {
        self.message.body.set_field(tag::ENCODED_LIST_EXEC_INST, FIXString::from(v));
    }

    /// Gets `EncodedListExecInst`, Tag 353.
    pub fn get_encoded_list_exec_inst(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::EncodedListExecInstField::new(String::new());
        self.message.body.get_field(tag::ENCODED_LIST_EXEC_INST, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `EncodedListExecInst` is present, Tag 353.
    pub fn has_encoded_list_exec_inst(&self) -> bool {
        self.message.body.has(tag::ENCODED_LIST_EXEC_INST)
    }




    /// Sets `EncodedListExecInstLen`, Tag 352.
    pub fn set_encoded_list_exec_inst_len(&mut self, v: isize) {
        self.message.body.set_field(tag::ENCODED_LIST_EXEC_INST_LEN, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `EncodedListExecInstLen`, Tag 352.
    pub fn get_encoded_list_exec_inst_len(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::EncodedListExecInstLenField::new(0);
        self.message.body.get_field(tag::ENCODED_LIST_EXEC_INST_LEN, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `EncodedListExecInstLen` is present, Tag 352.
    pub fn has_encoded_list_exec_inst_len(&self) -> bool {
        self.message.body.has(tag::ENCODED_LIST_EXEC_INST_LEN)
    }




    /// Sets `LastFragment`, Tag 893.
    pub fn set_last_fragment(&mut self, v: bool) {
        self.message.body.set_field(tag::LAST_FRAGMENT, fixer::fix_boolean::FIXBoolean::from(v));
    }

    /// Gets `LastFragment`, Tag 893.
    pub fn get_last_fragment(&self) -> Result<bool, MessageRejectErrorEnum> {
        let mut fld = field::LastFragmentField::new(false);
        self.message.body.get_field(tag::LAST_FRAGMENT, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `LastFragment` is present, Tag 893.
    pub fn has_last_fragment(&self) -> bool {
        self.message.body.has(tag::LAST_FRAGMENT)
    }




    /// Sets `ListExecInst`, Tag 69.
    pub fn set_list_exec_inst(&mut self, v: String) {
        self.message.body.set_field(tag::LIST_EXEC_INST, FIXString::from(v));
    }

    /// Gets `ListExecInst`, Tag 69.
    pub fn get_list_exec_inst(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::ListExecInstField::new(String::new());
        self.message.body.get_field(tag::LIST_EXEC_INST, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `ListExecInst` is present, Tag 69.
    pub fn has_list_exec_inst(&self) -> bool {
        self.message.body.has(tag::LIST_EXEC_INST)
    }




    /// Sets `ListExecInstType`, Tag 433.
    pub fn set_list_exec_inst_type(&mut self, v: String) {
        self.message.body.set_field(tag::LIST_EXEC_INST_TYPE, FIXString::from(v));
    }

    /// Gets `ListExecInstType`, Tag 433.
    pub fn get_list_exec_inst_type(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::ListExecInstTypeField::new(String::new());
        self.message.body.get_field(tag::LIST_EXEC_INST_TYPE, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `ListExecInstType` is present, Tag 433.
    pub fn has_list_exec_inst_type(&self) -> bool {
        self.message.body.has(tag::LIST_EXEC_INST_TYPE)
    }




    /// Sets `ListID`, Tag 66.
    pub fn set_list_id(&mut self, v: String) {
        self.message.body.set_field(tag::LIST_ID, FIXString::from(v));
    }

    /// Gets `ListID`, Tag 66.
    pub fn get_list_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::ListIDField::new(String::new());
        self.message.body.get_field(tag::LIST_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `ListID` is present, Tag 66.
    pub fn has_list_id(&self) -> bool {
        self.message.body.has(tag::LIST_ID)
    }




    /// Sets `MoneyLaunderingStatus`, Tag 481.
    pub fn set_money_laundering_status(&mut self, v: String) {
        self.message.body.set_field(tag::MONEY_LAUNDERING_STATUS, FIXString::from(v));
    }

    /// Gets `MoneyLaunderingStatus`, Tag 481.
    pub fn get_money_laundering_status(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::MoneyLaunderingStatusField::new(String::new());
        self.message.body.get_field(tag::MONEY_LAUNDERING_STATUS, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `MoneyLaunderingStatus` is present, Tag 481.
    pub fn has_money_laundering_status(&self) -> bool {
        self.message.body.has(tag::MONEY_LAUNDERING_STATUS)
    }




    /// Sets `NoOrders`, Tag 73.
    pub fn set_no_orders(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_ORDERS, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoOrders`, Tag 73.
    pub fn get_no_orders(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoOrdersField::new(0);
        self.message.body.get_field(tag::NO_ORDERS, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoOrders` is present, Tag 73.
    pub fn has_no_orders(&self) -> bool {
        self.message.body.has(tag::NO_ORDERS)
    }




    /// Sets `NoRootPartyIDs`, Tag 1116.
    pub fn set_no_root_party_i_ds(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_ROOT_PARTY_I_DS, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoRootPartyIDs`, Tag 1116.
    pub fn get_no_root_party_i_ds(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoRootPartyIDsField::new(0);
        self.message.body.get_field(tag::NO_ROOT_PARTY_I_DS, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoRootPartyIDs` is present, Tag 1116.
    pub fn has_no_root_party_i_ds(&self) -> bool {
        self.message.body.has(tag::NO_ROOT_PARTY_I_DS)
    }




    /// Sets `ProgPeriodInterval`, Tag 415.
    pub fn set_prog_period_interval(&mut self, v: isize) {
        self.message.body.set_field(tag::PROG_PERIOD_INTERVAL, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `ProgPeriodInterval`, Tag 415.
    pub fn get_prog_period_interval(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::ProgPeriodIntervalField::new(0);
        self.message.body.get_field(tag::PROG_PERIOD_INTERVAL, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ProgPeriodInterval` is present, Tag 415.
    pub fn has_prog_period_interval(&self) -> bool {
        self.message.body.has(tag::PROG_PERIOD_INTERVAL)
    }




    /// Sets `ProgRptReqs`, Tag 414.
    pub fn set_prog_rpt_reqs(&mut self, v: isize) {
        self.message.body.set_field(tag::PROG_RPT_REQS, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `ProgRptReqs`, Tag 414.
    pub fn get_prog_rpt_reqs(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::ProgRptReqsField::new(0);
        self.message.body.get_field(tag::PROG_RPT_REQS, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ProgRptReqs` is present, Tag 414.
    pub fn has_prog_rpt_reqs(&self) -> bool {
        self.message.body.has(tag::PROG_RPT_REQS)
    }




    /// Sets `RegistID`, Tag 513.
    pub fn set_regist_id(&mut self, v: String) {
        self.message.body.set_field(tag::REGIST_ID, FIXString::from(v));
    }

    /// Gets `RegistID`, Tag 513.
    pub fn get_regist_id(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::RegistIDField::new(String::new());
        self.message.body.get_field(tag::REGIST_ID, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `RegistID` is present, Tag 513.
    pub fn has_regist_id(&self) -> bool {
        self.message.body.has(tag::REGIST_ID)
    }




    /// Sets `TotNoOrders`, Tag 68.
    pub fn set_tot_no_orders(&mut self, v: isize) {
        self.message.body.set_field(tag::TOT_NO_ORDERS, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `TotNoOrders`, Tag 68.
    pub fn get_tot_no_orders(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::TotNoOrdersField::new(0);
        self.message.body.get_field(tag::TOT_NO_ORDERS, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `TotNoOrders` is present, Tag 68.
    pub fn has_tot_no_orders(&self) -> bool {
        self.message.body.has(tag::TOT_NO_ORDERS)
    }


}

/// `RouteOut` is the callback type for routing `NewOrderList` messages.
pub type RouteOut = fn(msg: NewOrderList, 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 `NewOrderList`.
pub fn route(router: RouteOut) -> Route {
    let r = move |msg: &Message, session_id: SessionID| -> Result<(), MessageRejectErrorEnum> {
        router(NewOrderList::from_message(msg.clone()), session_id)
    };
    ("7", "E", Box::new(r))
}