quickfix 0.2.1

High level binding to quickfix C++ library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};

use quickfix::*;

#[derive(Debug)]
pub struct FixRecorder {
    expected_session_id: SessionId,
    session_created: AtomicUsize,
    is_logged_in: AtomicBool,
    sent_admin: AtomicUsize,
    sent_user: AtomicUsize,
    recv_admin: AtomicUsize,
    recv_user: AtomicUsize,
}

impl FixRecorder {
    pub fn new(expected_session_id: SessionId) -> Self {
        Self {
            expected_session_id,
            session_created: AtomicUsize::new(0),
            is_logged_in: AtomicBool::new(false),
            sent_admin: AtomicUsize::new(0),
            sent_user: AtomicUsize::new(0),
            recv_admin: AtomicUsize::new(0),
            recv_user: AtomicUsize::new(0),
        }
    }

    pub fn session_created(&self) -> usize {
        self.session_created.load(Ordering::Relaxed)
    }

    pub fn is_logged_in(&self) -> bool {
        self.is_logged_in.load(Ordering::Relaxed)
    }

    pub fn admin_msg_count(&self) -> MsgCounter {
        MsgCounter {
            sent: self.sent_admin.load(Ordering::Relaxed),
            recv: self.recv_admin.load(Ordering::Relaxed),
        }
    }

    pub fn user_msg_count(&self) -> MsgCounter {
        MsgCounter {
            sent: self.sent_user.load(Ordering::Relaxed),
            recv: self.recv_user.load(Ordering::Relaxed),
        }
    }
}

impl ApplicationCallback for FixRecorder {
    fn on_create(&self, session_id: &SessionId) {
        self.session_created.fetch_add(1, Ordering::Relaxed);
        assert_session_id_equals(&self.expected_session_id, &session_id);
    }

    fn on_logon(&self, session_id: &SessionId) {
        self.is_logged_in.store(true, Ordering::Relaxed);
        assert_session_id_equals(&self.expected_session_id, &session_id);
    }

    fn on_logout(&self, session_id: &SessionId) {
        self.is_logged_in.store(false, Ordering::Relaxed);
        assert_session_id_equals(&self.expected_session_id, &session_id);
    }

    fn on_msg_to_admin(&self, _msg: &mut Message, session_id: &SessionId) {
        self.sent_admin.fetch_add(1, Ordering::Relaxed);
        assert_session_id_equals(&self.expected_session_id, &session_id);
    }

    fn on_msg_to_app(
        &self,
        _msg: &mut Message,
        session_id: &SessionId,
    ) -> Result<(), MsgToAppError> {
        self.sent_user.fetch_add(1, Ordering::Relaxed);
        assert_session_id_equals(&self.expected_session_id, &session_id);
        Ok(())
    }

    fn on_msg_from_admin(
        &self,
        _msg: &Message,
        session_id: &SessionId,
    ) -> Result<(), MsgFromAdminError> {
        self.recv_admin.fetch_add(1, Ordering::Relaxed);
        assert_session_id_equals(&self.expected_session_id, &session_id);
        Ok(())
    }

    fn on_msg_from_app(
        &self,
        _msg: &Message,
        session_id: &SessionId,
    ) -> Result<(), MsgFromAppError> {
        self.recv_user.fetch_add(1, Ordering::Relaxed);
        assert_session_id_equals(&self.expected_session_id, &session_id);
        Ok(())
    }
}

#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
pub struct MsgCounter {
    pub sent: usize,
    pub recv: usize,
}

fn assert_session_id_equals(a: &SessionId, b: &SessionId) {
    assert_eq!(a.to_repr(), b.to_repr());
}