quickfix-tokio 0.2.0

//! GENERATED by `generate-fix` — do not edit by hand.
#![allow(clippy::all, unused_imports, unused_mut, dead_code, non_upper_case_globals)]

//! One module per message; structs wrap [`crate::Message`] and expose
//! typed accessors. Constructors take the message's required fields.

pub mod heartbeat {
    use crate::field_map::{Field, FieldMap};
    use crate::error::ConversionError;
    use super::super::fields;

    /// Heartbeat (35=0).
    #[derive(Debug, Clone)]
    pub struct Heartbeat(pub crate::Message);
    impl Heartbeat {
        pub const MSG_TYPE: &'static str = "0";
        #[allow(clippy::too_many_arguments)]
        pub fn new() -> Self {
            let mut m = crate::Message::with_type(Self::MSG_TYPE);
            Self(m)
        }

        /// Wrap a generic message; fails unless 35="0".
        pub fn from_message(msg: crate::Message) -> Result<Self, crate::Message> {
            if msg.msg_type().ok().as_deref() == Some(Self::MSG_TYPE) { Ok(Self(msg)) } else { Err(msg) }
        }

        pub fn test_req_id(&self) -> Result<String, ConversionError> { self.0.body.get_field::<fields::TestReqID>() }
        pub fn set_test_req_id(&mut self, v: impl Into<String>) { self.0.body.set_field::<fields::TestReqID>(v.into()); }
        pub fn has_test_req_id(&self) -> bool { self.0.body.has_field::<fields::TestReqID>() }
    }
    impl std::ops::Deref for Heartbeat {
        type Target = crate::Message;
        fn deref(&self) -> &crate::Message { &self.0 }
    }
    impl std::ops::DerefMut for Heartbeat {
        fn deref_mut(&mut self) -> &mut crate::Message { &mut self.0 }
    }
    impl From<Heartbeat> for crate::Message {
        fn from(m: Heartbeat) -> crate::Message { m.0 }
    }

}
pub use heartbeat::Heartbeat;

pub mod logon {
    use crate::field_map::{Field, FieldMap};
    use crate::error::ConversionError;
    use super::super::fields;

    /// Logon (35=A).
    #[derive(Debug, Clone)]
    pub struct Logon(pub crate::Message);
    impl Logon {
        pub const MSG_TYPE: &'static str = "A";
        #[allow(clippy::too_many_arguments)]
        pub fn new(encrypt_method: i64, heart_bt_int: i64, default_appl_ver_id: impl Into<String>) -> Self {
            let mut m = crate::Message::with_type(Self::MSG_TYPE);
            m.body.set_field::<fields::EncryptMethod>(encrypt_method);
            m.body.set_field::<fields::HeartBtInt>(heart_bt_int);
            m.body.set_field::<fields::DefaultApplVerID>(default_appl_ver_id.into());
            Self(m)
        }

        /// Wrap a generic message; fails unless 35="A".
        pub fn from_message(msg: crate::Message) -> Result<Self, crate::Message> {
            if msg.msg_type().ok().as_deref() == Some(Self::MSG_TYPE) { Ok(Self(msg)) } else { Err(msg) }
        }

        pub fn encrypt_method(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::EncryptMethod>() }
        pub fn set_encrypt_method(&mut self, v: i64) { self.0.body.set_field::<fields::EncryptMethod>(v); }
        pub fn has_encrypt_method(&self) -> bool { self.0.body.has_field::<fields::EncryptMethod>() }
        pub fn heart_bt_int(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::HeartBtInt>() }
        pub fn set_heart_bt_int(&mut self, v: i64) { self.0.body.set_field::<fields::HeartBtInt>(v); }
        pub fn has_heart_bt_int(&self) -> bool { self.0.body.has_field::<fields::HeartBtInt>() }
        pub fn raw_data_length(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::RawDataLength>() }
        pub fn set_raw_data_length(&mut self, v: i64) { self.0.body.set_field::<fields::RawDataLength>(v); }
        pub fn has_raw_data_length(&self) -> bool { self.0.body.has_field::<fields::RawDataLength>() }
        pub fn raw_data(&self) -> Result<Vec<u8>, ConversionError> { self.0.body.get_field::<fields::RawData>() }
        pub fn set_raw_data(&mut self, v: impl Into<Vec<u8>>) { self.0.body.set_field::<fields::RawData>(v.into()); }
        pub fn has_raw_data(&self) -> bool { self.0.body.has_field::<fields::RawData>() }
        pub fn reset_seq_num_flag(&self) -> Result<bool, ConversionError> { self.0.body.get_field::<fields::ResetSeqNumFlag>() }
        pub fn set_reset_seq_num_flag(&mut self, v: bool) { self.0.body.set_field::<fields::ResetSeqNumFlag>(v); }
        pub fn has_reset_seq_num_flag(&self) -> bool { self.0.body.has_field::<fields::ResetSeqNumFlag>() }
        pub fn next_expected_msg_seq_num(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::NextExpectedMsgSeqNum>() }
        pub fn set_next_expected_msg_seq_num(&mut self, v: i64) { self.0.body.set_field::<fields::NextExpectedMsgSeqNum>(v); }
        pub fn has_next_expected_msg_seq_num(&self) -> bool { self.0.body.has_field::<fields::NextExpectedMsgSeqNum>() }
        pub fn max_message_size(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::MaxMessageSize>() }
        pub fn set_max_message_size(&mut self, v: i64) { self.0.body.set_field::<fields::MaxMessageSize>(v); }
        pub fn has_max_message_size(&self) -> bool { self.0.body.has_field::<fields::MaxMessageSize>() }
        pub fn test_message_indicator(&self) -> Result<bool, ConversionError> { self.0.body.get_field::<fields::TestMessageIndicator>() }
        pub fn set_test_message_indicator(&mut self, v: bool) { self.0.body.set_field::<fields::TestMessageIndicator>(v); }
        pub fn has_test_message_indicator(&self) -> bool { self.0.body.has_field::<fields::TestMessageIndicator>() }
        pub fn username(&self) -> Result<String, ConversionError> { self.0.body.get_field::<fields::Username>() }
        pub fn set_username(&mut self, v: impl Into<String>) { self.0.body.set_field::<fields::Username>(v.into()); }
        pub fn has_username(&self) -> bool { self.0.body.has_field::<fields::Username>() }
        pub fn password(&self) -> Result<String, ConversionError> { self.0.body.get_field::<fields::Password>() }
        pub fn set_password(&mut self, v: impl Into<String>) { self.0.body.set_field::<fields::Password>(v.into()); }
        pub fn has_password(&self) -> bool { self.0.body.has_field::<fields::Password>() }
        pub fn default_appl_ver_id(&self) -> Result<String, ConversionError> { self.0.body.get_field::<fields::DefaultApplVerID>() }
        pub fn set_default_appl_ver_id(&mut self, v: impl Into<String>) { self.0.body.set_field::<fields::DefaultApplVerID>(v.into()); }
        pub fn has_default_appl_ver_id(&self) -> bool { self.0.body.has_field::<fields::DefaultApplVerID>() }
        pub fn no_msg_types(&self) -> Result<Vec<NoMsgTypes>, ConversionError> {
            Ok(self.0.body.read_groups(&no_msg_types_template())?.into_iter().map(NoMsgTypes).collect())
        }
        pub fn set_no_msg_types(&mut self, groups: impl IntoIterator<Item = NoMsgTypes>) {
            let maps: Vec<FieldMap> = groups.into_iter().map(|g| g.0).collect();
            self.0.body.write_groups(&no_msg_types_template(), &maps);
        }
    }
    impl std::ops::Deref for Logon {
        type Target = crate::Message;
        fn deref(&self) -> &crate::Message { &self.0 }
    }
    impl std::ops::DerefMut for Logon {
        fn deref_mut(&mut self) -> &mut crate::Message { &mut self.0 }
    }
    impl From<Logon> for crate::Message {
        fn from(m: Logon) -> crate::Message { m.0 }
    }


    pub(crate) fn no_msg_types_template() -> crate::GroupTemplate {
        crate::GroupTemplate::new(384, vec![372, 385, 1130, 1131])
    }
    /// Repeating group counted by NoMsgTypes (384). Set the delimiter
    /// field (372) first.
    #[derive(Debug, Clone, Default)]
    pub struct NoMsgTypes(pub FieldMap);
    impl NoMsgTypes {
        pub fn new() -> Self { Self(FieldMap::new()) }
        pub fn ref_msg_type(&self) -> Result<String, ConversionError> { self.0.get_field::<fields::RefMsgType>() }
        pub fn set_ref_msg_type(&mut self, v: impl Into<String>) { self.0.set_field::<fields::RefMsgType>(v.into()); }
        pub fn has_ref_msg_type(&self) -> bool { self.0.has_field::<fields::RefMsgType>() }
        pub fn msg_direction(&self) -> Result<char, ConversionError> { self.0.get_field::<fields::MsgDirection>() }
        pub fn set_msg_direction(&mut self, v: char) { self.0.set_field::<fields::MsgDirection>(v); }
        pub fn has_msg_direction(&self) -> bool { self.0.has_field::<fields::MsgDirection>() }
        pub fn ref_appl_ver_id(&self) -> Result<String, ConversionError> { self.0.get_field::<fields::RefApplVerID>() }
        pub fn set_ref_appl_ver_id(&mut self, v: impl Into<String>) { self.0.set_field::<fields::RefApplVerID>(v.into()); }
        pub fn has_ref_appl_ver_id(&self) -> bool { self.0.has_field::<fields::RefApplVerID>() }
        pub fn ref_cstm_appl_ver_id(&self) -> Result<String, ConversionError> { self.0.get_field::<fields::RefCstmApplVerID>() }
        pub fn set_ref_cstm_appl_ver_id(&mut self, v: impl Into<String>) { self.0.set_field::<fields::RefCstmApplVerID>(v.into()); }
        pub fn has_ref_cstm_appl_ver_id(&self) -> bool { self.0.has_field::<fields::RefCstmApplVerID>() }
    }
}
pub use logon::Logon;

pub mod logout {
    use crate::field_map::{Field, FieldMap};
    use crate::error::ConversionError;
    use super::super::fields;

    /// Logout (35=5).
    #[derive(Debug, Clone)]
    pub struct Logout(pub crate::Message);
    impl Logout {
        pub const MSG_TYPE: &'static str = "5";
        #[allow(clippy::too_many_arguments)]
        pub fn new() -> Self {
            let mut m = crate::Message::with_type(Self::MSG_TYPE);
            Self(m)
        }

        /// Wrap a generic message; fails unless 35="5".
        pub fn from_message(msg: crate::Message) -> Result<Self, crate::Message> {
            if msg.msg_type().ok().as_deref() == Some(Self::MSG_TYPE) { Ok(Self(msg)) } else { Err(msg) }
        }

        pub fn text(&self) -> Result<String, ConversionError> { self.0.body.get_field::<fields::Text>() }
        pub fn set_text(&mut self, v: impl Into<String>) { self.0.body.set_field::<fields::Text>(v.into()); }
        pub fn has_text(&self) -> bool { self.0.body.has_field::<fields::Text>() }
        pub fn encoded_text_len(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::EncodedTextLen>() }
        pub fn set_encoded_text_len(&mut self, v: i64) { self.0.body.set_field::<fields::EncodedTextLen>(v); }
        pub fn has_encoded_text_len(&self) -> bool { self.0.body.has_field::<fields::EncodedTextLen>() }
        pub fn encoded_text(&self) -> Result<Vec<u8>, ConversionError> { self.0.body.get_field::<fields::EncodedText>() }
        pub fn set_encoded_text(&mut self, v: impl Into<Vec<u8>>) { self.0.body.set_field::<fields::EncodedText>(v.into()); }
        pub fn has_encoded_text(&self) -> bool { self.0.body.has_field::<fields::EncodedText>() }
    }
    impl std::ops::Deref for Logout {
        type Target = crate::Message;
        fn deref(&self) -> &crate::Message { &self.0 }
    }
    impl std::ops::DerefMut for Logout {
        fn deref_mut(&mut self) -> &mut crate::Message { &mut self.0 }
    }
    impl From<Logout> for crate::Message {
        fn from(m: Logout) -> crate::Message { m.0 }
    }

}
pub use logout::Logout;

pub mod reject {
    use crate::field_map::{Field, FieldMap};
    use crate::error::ConversionError;
    use super::super::fields;

    /// Reject (35=3).
    #[derive(Debug, Clone)]
    pub struct Reject(pub crate::Message);
    impl Reject {
        pub const MSG_TYPE: &'static str = "3";
        #[allow(clippy::too_many_arguments)]
        pub fn new(ref_seq_num: i64) -> Self {
            let mut m = crate::Message::with_type(Self::MSG_TYPE);
            m.body.set_field::<fields::RefSeqNum>(ref_seq_num);
            Self(m)
        }

        /// Wrap a generic message; fails unless 35="3".
        pub fn from_message(msg: crate::Message) -> Result<Self, crate::Message> {
            if msg.msg_type().ok().as_deref() == Some(Self::MSG_TYPE) { Ok(Self(msg)) } else { Err(msg) }
        }

        pub fn ref_seq_num(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::RefSeqNum>() }
        pub fn set_ref_seq_num(&mut self, v: i64) { self.0.body.set_field::<fields::RefSeqNum>(v); }
        pub fn has_ref_seq_num(&self) -> bool { self.0.body.has_field::<fields::RefSeqNum>() }
        pub fn ref_tag_id(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::RefTagID>() }
        pub fn set_ref_tag_id(&mut self, v: i64) { self.0.body.set_field::<fields::RefTagID>(v); }
        pub fn has_ref_tag_id(&self) -> bool { self.0.body.has_field::<fields::RefTagID>() }
        pub fn ref_msg_type(&self) -> Result<String, ConversionError> { self.0.body.get_field::<fields::RefMsgType>() }
        pub fn set_ref_msg_type(&mut self, v: impl Into<String>) { self.0.body.set_field::<fields::RefMsgType>(v.into()); }
        pub fn has_ref_msg_type(&self) -> bool { self.0.body.has_field::<fields::RefMsgType>() }
        pub fn session_reject_reason(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::SessionRejectReason>() }
        pub fn set_session_reject_reason(&mut self, v: i64) { self.0.body.set_field::<fields::SessionRejectReason>(v); }
        pub fn has_session_reject_reason(&self) -> bool { self.0.body.has_field::<fields::SessionRejectReason>() }
        pub fn text(&self) -> Result<String, ConversionError> { self.0.body.get_field::<fields::Text>() }
        pub fn set_text(&mut self, v: impl Into<String>) { self.0.body.set_field::<fields::Text>(v.into()); }
        pub fn has_text(&self) -> bool { self.0.body.has_field::<fields::Text>() }
        pub fn encoded_text_len(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::EncodedTextLen>() }
        pub fn set_encoded_text_len(&mut self, v: i64) { self.0.body.set_field::<fields::EncodedTextLen>(v); }
        pub fn has_encoded_text_len(&self) -> bool { self.0.body.has_field::<fields::EncodedTextLen>() }
        pub fn encoded_text(&self) -> Result<Vec<u8>, ConversionError> { self.0.body.get_field::<fields::EncodedText>() }
        pub fn set_encoded_text(&mut self, v: impl Into<Vec<u8>>) { self.0.body.set_field::<fields::EncodedText>(v.into()); }
        pub fn has_encoded_text(&self) -> bool { self.0.body.has_field::<fields::EncodedText>() }
    }
    impl std::ops::Deref for Reject {
        type Target = crate::Message;
        fn deref(&self) -> &crate::Message { &self.0 }
    }
    impl std::ops::DerefMut for Reject {
        fn deref_mut(&mut self) -> &mut crate::Message { &mut self.0 }
    }
    impl From<Reject> for crate::Message {
        fn from(m: Reject) -> crate::Message { m.0 }
    }

}
pub use reject::Reject;

pub mod resend_request {
    use crate::field_map::{Field, FieldMap};
    use crate::error::ConversionError;
    use super::super::fields;

    /// ResendRequest (35=2).
    #[derive(Debug, Clone)]
    pub struct ResendRequest(pub crate::Message);
    impl ResendRequest {
        pub const MSG_TYPE: &'static str = "2";
        #[allow(clippy::too_many_arguments)]
        pub fn new(begin_seq_no: i64, end_seq_no: i64) -> Self {
            let mut m = crate::Message::with_type(Self::MSG_TYPE);
            m.body.set_field::<fields::BeginSeqNo>(begin_seq_no);
            m.body.set_field::<fields::EndSeqNo>(end_seq_no);
            Self(m)
        }

        /// Wrap a generic message; fails unless 35="2".
        pub fn from_message(msg: crate::Message) -> Result<Self, crate::Message> {
            if msg.msg_type().ok().as_deref() == Some(Self::MSG_TYPE) { Ok(Self(msg)) } else { Err(msg) }
        }

        pub fn begin_seq_no(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::BeginSeqNo>() }
        pub fn set_begin_seq_no(&mut self, v: i64) { self.0.body.set_field::<fields::BeginSeqNo>(v); }
        pub fn has_begin_seq_no(&self) -> bool { self.0.body.has_field::<fields::BeginSeqNo>() }
        pub fn end_seq_no(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::EndSeqNo>() }
        pub fn set_end_seq_no(&mut self, v: i64) { self.0.body.set_field::<fields::EndSeqNo>(v); }
        pub fn has_end_seq_no(&self) -> bool { self.0.body.has_field::<fields::EndSeqNo>() }
    }
    impl std::ops::Deref for ResendRequest {
        type Target = crate::Message;
        fn deref(&self) -> &crate::Message { &self.0 }
    }
    impl std::ops::DerefMut for ResendRequest {
        fn deref_mut(&mut self) -> &mut crate::Message { &mut self.0 }
    }
    impl From<ResendRequest> for crate::Message {
        fn from(m: ResendRequest) -> crate::Message { m.0 }
    }

}
pub use resend_request::ResendRequest;

pub mod sequence_reset {
    use crate::field_map::{Field, FieldMap};
    use crate::error::ConversionError;
    use super::super::fields;

    /// SequenceReset (35=4).
    #[derive(Debug, Clone)]
    pub struct SequenceReset(pub crate::Message);
    impl SequenceReset {
        pub const MSG_TYPE: &'static str = "4";
        #[allow(clippy::too_many_arguments)]
        pub fn new(new_seq_no: i64) -> Self {
            let mut m = crate::Message::with_type(Self::MSG_TYPE);
            m.body.set_field::<fields::NewSeqNo>(new_seq_no);
            Self(m)
        }

        /// Wrap a generic message; fails unless 35="4".
        pub fn from_message(msg: crate::Message) -> Result<Self, crate::Message> {
            if msg.msg_type().ok().as_deref() == Some(Self::MSG_TYPE) { Ok(Self(msg)) } else { Err(msg) }
        }

        pub fn gap_fill_flag(&self) -> Result<bool, ConversionError> { self.0.body.get_field::<fields::GapFillFlag>() }
        pub fn set_gap_fill_flag(&mut self, v: bool) { self.0.body.set_field::<fields::GapFillFlag>(v); }
        pub fn has_gap_fill_flag(&self) -> bool { self.0.body.has_field::<fields::GapFillFlag>() }
        pub fn new_seq_no(&self) -> Result<i64, ConversionError> { self.0.body.get_field::<fields::NewSeqNo>() }
        pub fn set_new_seq_no(&mut self, v: i64) { self.0.body.set_field::<fields::NewSeqNo>(v); }
        pub fn has_new_seq_no(&self) -> bool { self.0.body.has_field::<fields::NewSeqNo>() }
    }
    impl std::ops::Deref for SequenceReset {
        type Target = crate::Message;
        fn deref(&self) -> &crate::Message { &self.0 }
    }
    impl std::ops::DerefMut for SequenceReset {
        fn deref_mut(&mut self) -> &mut crate::Message { &mut self.0 }
    }
    impl From<SequenceReset> for crate::Message {
        fn from(m: SequenceReset) -> crate::Message { m.0 }
    }

}
pub use sequence_reset::SequenceReset;

pub mod test_request {
    use crate::field_map::{Field, FieldMap};
    use crate::error::ConversionError;
    use super::super::fields;

    /// TestRequest (35=1).
    #[derive(Debug, Clone)]
    pub struct TestRequest(pub crate::Message);
    impl TestRequest {
        pub const MSG_TYPE: &'static str = "1";
        #[allow(clippy::too_many_arguments)]
        pub fn new(test_req_id: impl Into<String>) -> Self {
            let mut m = crate::Message::with_type(Self::MSG_TYPE);
            m.body.set_field::<fields::TestReqID>(test_req_id.into());
            Self(m)
        }

        /// Wrap a generic message; fails unless 35="1".
        pub fn from_message(msg: crate::Message) -> Result<Self, crate::Message> {
            if msg.msg_type().ok().as_deref() == Some(Self::MSG_TYPE) { Ok(Self(msg)) } else { Err(msg) }
        }

        pub fn test_req_id(&self) -> Result<String, ConversionError> { self.0.body.get_field::<fields::TestReqID>() }
        pub fn set_test_req_id(&mut self, v: impl Into<String>) { self.0.body.set_field::<fields::TestReqID>(v.into()); }
        pub fn has_test_req_id(&self) -> bool { self.0.body.has_field::<fields::TestReqID>() }
    }
    impl std::ops::Deref for TestRequest {
        type Target = crate::Message;
        fn deref(&self) -> &crate::Message { &self.0 }
    }
    impl std::ops::DerefMut for TestRequest {
        fn deref_mut(&mut self) -> &mut crate::Message { &mut self.0 }
    }
    impl From<TestRequest> for crate::Message {
        fn from(m: TestRequest) -> crate::Message { m.0 }
    }

}
pub use test_request::TestRequest;