Struct Initiator

pub struct Initiator<'a, A, L, S>
where
    A: ApplicationCallback,
    S: FfiMessageStoreFactory,
    L: LogCallback,
{ /* private fields */ }

Socket implementation of establishing connections handler.

Implementations

impl<'a, A, L, S> Initiator<'a, A, L, S>

where A: ApplicationCallback, S: FfiMessageStoreFactory, L: LogCallback,

pub fn try_new( settings: &SessionSettings, application: &'a Application<'_, A>, store_factory: &'a S, log_factory: &'a LogFactory<'_, L>, server_mode: FixSocketServerKind, ) -> Result<Self, QuickFixError>

Try create new struct from its mandatory components.

Examples found in repository

examples/fix_repl/main.rs (lines 32-38)

fn main() -> Result<(), QuickFixError> {
    let args: Vec<_> = env::args().collect();
    let (Some(connect_mode), Some(config_file)) = (args.get(1), args.get(2)) else {
        eprintln!(
            "Bad program usage: {} [acceptor|initiator] <config_file>",
            args[0]
        );
        exit(1);
    };

    println!(">> Creating resources");
    let settings = SessionSettings::try_from_path(config_file)?;
    let store_factory = FileMessageStoreFactory::try_new(&settings)?;
    let log_factory = LogFactory::try_new(&StdLogger::Stdout)?;
    let callbacks = MyApplication::new();
    let app = Application::try_new(&callbacks)?;

    match connect_mode.as_str() {
        "initiator" => server_loop(Initiator::try_new(
            &settings,
            &app,
            &store_factory,
            &log_factory,
            FixSocketServerKind::SingleThreaded,
        )?),
        "acceptor" => server_loop(Acceptor::try_new(
            &settings,
            &app,
            &store_factory,
            &log_factory,
            FixSocketServerKind::SingleThreaded,
        )?),
        _ => {
            eprintln!("Invalid connection mode");
            exit(1);
        }
    }?;

    println!(">> All cleared. Bye !");
    Ok(())
}

Trait Implementations

impl<A, L, S> ConnectionHandler for Initiator<'_, A, L, S>

where A: ApplicationCallback, S: FfiMessageStoreFactory, L: LogCallback,

fn start(&mut self) -> Result<(), QuickFixError>

Start handler.

fn block(&mut self) -> Result<(), QuickFixError>

Block handler.

fn poll(&mut self) -> Result<bool, QuickFixError>

Poll handler.

fn stop(&mut self) -> Result<(), QuickFixError>

Stop handler.

fn is_logged_on(&self) -> Result<bool, QuickFixError>

Check if handler has sent logging message or not.

fn is_stopped(&self) -> Result<bool, QuickFixError>

Check if handler is currently working or not.

impl<'a, A, L, S> Debug for Initiator<'a, A, L, S>

where A: ApplicationCallback + Debug, S: FfiMessageStoreFactory + Debug, L: LogCallback + Debug,

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

Formats the value using the given formatter.

impl<A, L, S> Drop for Initiator<'_, A, L, S>

where A: ApplicationCallback, S: FfiMessageStoreFactory, L: LogCallback,

fn drop(&mut self)

Executes the destructor for this type.

impl<A, L, S> SessionContainer for Initiator<'_, A, L, S>

where A: ApplicationCallback, S: FfiMessageStoreFactory, L: LogCallback,

fn session(&self, session_id: SessionId) -> Result<Session<'_>, QuickFixError>

Borrow mutable session to the container.