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;

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

impl BidRequest {
    /// Creates a new `BidRequest` with required fields.
    pub fn new(client_bid_id: field::ClientBidIDField, bid_request_trans_type: field::BidRequestTransTypeField, tot_no_related_sym: field::TotNoRelatedSymField, bid_type: field::BidTypeField, bid_trade_type: field::BidTradeTypeField, basis_px_type: field::BasisPxTypeField) -> Self {
        let mut msg = Message::new();
        msg.header.set_field(tag::MSG_TYPE, FIXString::from("k".to_string()));

        msg.body.set_field(tag::CLIENT_BID_ID, client_bid_id.0);

        msg.body.set_field(tag::BID_REQUEST_TRANS_TYPE, bid_request_trans_type.0);

        msg.body.set_field(tag::TOT_NO_RELATED_SYM, tot_no_related_sym.0);

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

        msg.body.set_field(tag::BID_TRADE_TYPE, bid_trade_type.0);

        msg.body.set_field(tag::BASIS_PX_TYPE, basis_px_type.0);

        Self { message: msg }
    }

    /// Creates a `BidRequest` 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 `BasisPxType`, Tag 419.
    pub fn set_basis_px_type(&mut self, v: String) {
        self.message.body.set_field(tag::BASIS_PX_TYPE, FIXString::from(v));
    }

    /// Gets `BasisPxType`, Tag 419.
    pub fn get_basis_px_type(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::BasisPxTypeField::new(String::new());
        self.message.body.get_field(tag::BASIS_PX_TYPE, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `BasisPxType` is present, Tag 419.
    pub fn has_basis_px_type(&self) -> bool {
        self.message.body.has(tag::BASIS_PX_TYPE)
    }




    /// 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 `BidRequestTransType`, Tag 374.
    pub fn set_bid_request_trans_type(&mut self, v: String) {
        self.message.body.set_field(tag::BID_REQUEST_TRANS_TYPE, FIXString::from(v));
    }

    /// Gets `BidRequestTransType`, Tag 374.
    pub fn get_bid_request_trans_type(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::BidRequestTransTypeField::new(String::new());
        self.message.body.get_field(tag::BID_REQUEST_TRANS_TYPE, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `BidRequestTransType` is present, Tag 374.
    pub fn has_bid_request_trans_type(&self) -> bool {
        self.message.body.has(tag::BID_REQUEST_TRANS_TYPE)
    }




    /// Sets `BidTradeType`, Tag 418.
    pub fn set_bid_trade_type(&mut self, v: String) {
        self.message.body.set_field(tag::BID_TRADE_TYPE, FIXString::from(v));
    }

    /// Gets `BidTradeType`, Tag 418.
    pub fn get_bid_trade_type(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::BidTradeTypeField::new(String::new());
        self.message.body.get_field(tag::BID_TRADE_TYPE, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `BidTradeType` is present, Tag 418.
    pub fn has_bid_trade_type(&self) -> bool {
        self.message.body.has(tag::BID_TRADE_TYPE)
    }




    /// 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 `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 `CrossPercent`, Tag 413.
    pub fn set_cross_percent(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::CROSS_PERCENT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `CrossPercent`, Tag 413.
    pub fn get_cross_percent(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::CrossPercentField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::CROSS_PERCENT, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `CrossPercent` is present, Tag 413.
    pub fn has_cross_percent(&self) -> bool {
        self.message.body.has(tag::CROSS_PERCENT)
    }




    /// 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 `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 `ExchangeForPhysical`, Tag 411.
    pub fn set_exchange_for_physical(&mut self, v: bool) {
        self.message.body.set_field(tag::EXCHANGE_FOR_PHYSICAL, fixer::fix_boolean::FIXBoolean::from(v));
    }

    /// Gets `ExchangeForPhysical`, Tag 411.
    pub fn get_exchange_for_physical(&self) -> Result<bool, MessageRejectErrorEnum> {
        let mut fld = field::ExchangeForPhysicalField::new(false);
        self.message.body.get_field(tag::EXCHANGE_FOR_PHYSICAL, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ExchangeForPhysical` is present, Tag 411.
    pub fn has_exchange_for_physical(&self) -> bool {
        self.message.body.has(tag::EXCHANGE_FOR_PHYSICAL)
    }




    /// Sets `ForexReq`, Tag 121.
    pub fn set_forex_req(&mut self, v: bool) {
        self.message.body.set_field(tag::FOREX_REQ, fixer::fix_boolean::FIXBoolean::from(v));
    }

    /// Gets `ForexReq`, Tag 121.
    pub fn get_forex_req(&self) -> Result<bool, MessageRejectErrorEnum> {
        let mut fld = field::ForexReqField::new(false);
        self.message.body.get_field(tag::FOREX_REQ, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `ForexReq` is present, Tag 121.
    pub fn has_forex_req(&self) -> bool {
        self.message.body.has(tag::FOREX_REQ)
    }




    /// Sets `IncTaxInd`, Tag 416.
    pub fn set_inc_tax_ind(&mut self, v: isize) {
        self.message.body.set_field(tag::INC_TAX_IND, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `IncTaxInd`, Tag 416.
    pub fn get_inc_tax_ind(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::IncTaxIndField::new(0);
        self.message.body.get_field(tag::INC_TAX_IND, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `IncTaxInd` is present, Tag 416.
    pub fn has_inc_tax_ind(&self) -> bool {
        self.message.body.has(tag::INC_TAX_IND)
    }




    /// Sets `LiquidityIndType`, Tag 409.
    pub fn set_liquidity_ind_type(&mut self, v: isize) {
        self.message.body.set_field(tag::LIQUIDITY_IND_TYPE, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `LiquidityIndType`, Tag 409.
    pub fn get_liquidity_ind_type(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::LiquidityIndTypeField::new(0);
        self.message.body.get_field(tag::LIQUIDITY_IND_TYPE, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `LiquidityIndType` is present, Tag 409.
    pub fn has_liquidity_ind_type(&self) -> bool {
        self.message.body.has(tag::LIQUIDITY_IND_TYPE)
    }




    /// Sets `ListName`, Tag 392.
    pub fn set_list_name(&mut self, v: String) {
        self.message.body.set_field(tag::LIST_NAME, FIXString::from(v));
    }

    /// Gets `ListName`, Tag 392.
    pub fn get_list_name(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::ListNameField::new(String::new());
        self.message.body.get_field(tag::LIST_NAME, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `ListName` is present, Tag 392.
    pub fn has_list_name(&self) -> bool {
        self.message.body.has(tag::LIST_NAME)
    }




    /// Sets `NoBidComponents`, Tag 420.
    pub fn set_no_bid_components(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_BID_COMPONENTS, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoBidComponents`, Tag 420.
    pub fn get_no_bid_components(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoBidComponentsField::new(0);
        self.message.body.get_field(tag::NO_BID_COMPONENTS, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoBidComponents` is present, Tag 420.
    pub fn has_no_bid_components(&self) -> bool {
        self.message.body.has(tag::NO_BID_COMPONENTS)
    }




    /// Sets `NoBidDescriptors`, Tag 398.
    pub fn set_no_bid_descriptors(&mut self, v: isize) {
        self.message.body.set_field(tag::NO_BID_DESCRIPTORS, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NoBidDescriptors`, Tag 398.
    pub fn get_no_bid_descriptors(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NoBidDescriptorsField::new(0);
        self.message.body.get_field(tag::NO_BID_DESCRIPTORS, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NoBidDescriptors` is present, Tag 398.
    pub fn has_no_bid_descriptors(&self) -> bool {
        self.message.body.has(tag::NO_BID_DESCRIPTORS)
    }




    /// Sets `NumBidders`, Tag 417.
    pub fn set_num_bidders(&mut self, v: isize) {
        self.message.body.set_field(tag::NUM_BIDDERS, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NumBidders`, Tag 417.
    pub fn get_num_bidders(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NumBiddersField::new(0);
        self.message.body.get_field(tag::NUM_BIDDERS, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NumBidders` is present, Tag 417.
    pub fn has_num_bidders(&self) -> bool {
        self.message.body.has(tag::NUM_BIDDERS)
    }




    /// Sets `NumTickets`, Tag 395.
    pub fn set_num_tickets(&mut self, v: isize) {
        self.message.body.set_field(tag::NUM_TICKETS, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `NumTickets`, Tag 395.
    pub fn get_num_tickets(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::NumTicketsField::new(0);
        self.message.body.get_field(tag::NUM_TICKETS, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `NumTickets` is present, Tag 395.
    pub fn has_num_tickets(&self) -> bool {
        self.message.body.has(tag::NUM_TICKETS)
    }




    /// Sets `OutMainCntryUIndex`, Tag 412.
    pub fn set_out_main_cntry_u_index(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::OUT_MAIN_CNTRY_U_INDEX, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `OutMainCntryUIndex`, Tag 412.
    pub fn get_out_main_cntry_u_index(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::OutMainCntryUIndexField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::OUT_MAIN_CNTRY_U_INDEX, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `OutMainCntryUIndex` is present, Tag 412.
    pub fn has_out_main_cntry_u_index(&self) -> bool {
        self.message.body.has(tag::OUT_MAIN_CNTRY_U_INDEX)
    }




    /// 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 `SideValue1`, Tag 396.
    pub fn set_side_value1(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::SIDE_VALUE1, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `SideValue1`, Tag 396.
    pub fn get_side_value1(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::SideValue1Field::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::SIDE_VALUE1, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `SideValue1` is present, Tag 396.
    pub fn has_side_value1(&self) -> bool {
        self.message.body.has(tag::SIDE_VALUE1)
    }




    /// Sets `SideValue2`, Tag 397.
    pub fn set_side_value2(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::SIDE_VALUE2, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `SideValue2`, Tag 397.
    pub fn get_side_value2(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::SideValue2Field::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::SIDE_VALUE2, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `SideValue2` is present, Tag 397.
    pub fn has_side_value2(&self) -> bool {
        self.message.body.has(tag::SIDE_VALUE2)
    }




    /// Sets `StrikeTime`, Tag 443.
    pub fn set_strike_time(&mut self, v: Timestamp) {
        self.message.body.set_field(tag::STRIKE_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
            time: v,
            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
        });
    }

    /// Gets `StrikeTime`, Tag 443.
    pub fn get_strike_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
        let mut fld = field::StrikeTimeField::new(Timestamp::UNIX_EPOCH);
        self.message.body.get_field(tag::STRIKE_TIME, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `StrikeTime` is present, Tag 443.
    pub fn has_strike_time(&self) -> bool {
        self.message.body.has(tag::STRIKE_TIME)
    }




    /// 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 `TotNoRelatedSym`, Tag 393.
    pub fn set_tot_no_related_sym(&mut self, v: isize) {
        self.message.body.set_field(tag::TOT_NO_RELATED_SYM, fixer::fix_int::FIXInt::from(v));
    }

    /// Gets `TotNoRelatedSym`, Tag 393.
    pub fn get_tot_no_related_sym(&self) -> Result<isize, MessageRejectErrorEnum> {
        let mut fld = field::TotNoRelatedSymField::new(0);
        self.message.body.get_field(tag::TOT_NO_RELATED_SYM, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `TotNoRelatedSym` is present, Tag 393.
    pub fn has_tot_no_related_sym(&self) -> bool {
        self.message.body.has(tag::TOT_NO_RELATED_SYM)
    }




    /// Sets `TradeDate`, Tag 75.
    pub fn set_trade_date(&mut self, v: String) {
        self.message.body.set_field(tag::TRADE_DATE, FIXString::from(v));
    }

    /// Gets `TradeDate`, Tag 75.
    pub fn get_trade_date(&self) -> Result<String, MessageRejectErrorEnum> {
        let mut fld = field::TradeDateField::new(String::new());
        self.message.body.get_field(tag::TRADE_DATE, &mut fld.0)?;
        Ok(fld.value().to_string())
    }


    /// Returns true if `TradeDate` is present, Tag 75.
    pub fn has_trade_date(&self) -> bool {
        self.message.body.has(tag::TRADE_DATE)
    }




    /// Sets `WtAverageLiquidity`, Tag 410.
    pub fn set_wt_average_liquidity(&mut self, val: Decimal, scale: i32) {
        self.message.body.set_field(tag::WT_AVERAGE_LIQUIDITY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
    }

    /// Gets `WtAverageLiquidity`, Tag 410.
    pub fn get_wt_average_liquidity(&self) -> Result<Decimal, MessageRejectErrorEnum> {
        let mut fld = field::WtAverageLiquidityField::new(Decimal::ZERO, 0);
        self.message.body.get_field(tag::WT_AVERAGE_LIQUIDITY, &mut fld.0)?;
        Ok(fld.value())
    }


    /// Returns true if `WtAverageLiquidity` is present, Tag 410.
    pub fn has_wt_average_liquidity(&self) -> bool {
        self.message.body.has(tag::WT_AVERAGE_LIQUIDITY)
    }


}

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