mqi 0.3.0

Idiomatic IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) APIs
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::{
    MqStr,
    string::{CCSID, StrCcsidOwned},
    structs,
    types::{MQCC, MQCHAR, MQLONG, MQOO, MQOT, MQRC, MQSO, ObjectName},
};

impl AsyncPutStat {
    pub(crate) fn new(sts: &structs::MQSTS, buffer: Vec<MQCHAR>) -> Self {
        let mut buffer = buffer;
        unsafe {
            buffer.set_len(
                sts.ObjectString
                    .VSLength
                    .try_into()
                    .expect("buffer length should convert to usize"),
            );
        }

        Self {
            warning: match sts.CompCode {
                0 => None,
                value => Some(MQCC::from(value)),
            },
            reason: MQRC::from(sts.Reason),
            put_success_count: sts.PutSuccessCount,
            put_warning_count: sts.PutWarningCount,
            put_failure_count: sts.PutFailureCount,
            object_type: MQOT(sts.ObjectType),
            object_name: MqStr::from(sts.ObjectName),
            object_qmgr_name: MqStr::from(sts.ObjectQMgrName),
            resolved_object_name: MqStr::from(sts.ResolvedObjectName),
            resolved_object_qmgr_name: MqStr::from(sts.ResolvedQMgrName),
            object_string: if buffer.is_empty() {
                None
            } else {
                Some(StrCcsidOwned::from_vec(buffer, CCSID(sts.ObjectString.VSCCSID)))
            },
        }
    }
}

impl ReconnectionStat {
    pub(crate) fn new(sts: &structs::MQSTS) -> Self {
        Self {
            warning: match sts.CompCode {
                0 => None,
                value => Some(MQCC::from(value)),
            },
            reason: MQRC::from(sts.Reason),
            object_type: MQOT(sts.ObjectType),
            object_name: MqStr::from(sts.ObjectName),
            object_qmgr_name: MqStr::from(sts.ObjectQMgrName),
        }
    }
}

impl ReconnectionErrorStat {
    pub(crate) fn new(sts: &structs::MQSTS, object_string_buffer: Vec<MQCHAR>, sub_name_buffer: Vec<MQCHAR>) -> Self {
        let mut object_string_buffer = object_string_buffer;
        unsafe {
            object_string_buffer.set_len(
                sts.ObjectString
                    .VSLength
                    .try_into()
                    .expect("buffer length should convert to usize"),
            );
        }
        let mut sub_name_buffer = sub_name_buffer;
        unsafe {
            sub_name_buffer.set_len(
                sts.SubName
                    .VSLength
                    .try_into()
                    .expect("buffer length should convert to usize"),
            );
        }

        Self {
            warning: match sts.CompCode {
                0 => None,
                value => Some(MQCC::from(value)),
            },
            reason: MQRC::from(sts.Reason),
            object_type: MQOT(sts.ObjectType),
            object_name: MqStr::from(sts.ObjectName),
            object_qmgr_name: MqStr::from(sts.ObjectQMgrName),
            object_string: if object_string_buffer.is_empty() {
                None
            } else {
                Some(StrCcsidOwned::from_vec(object_string_buffer, CCSID(sts.ObjectString.VSCCSID)))
            },
            sub_name: if sub_name_buffer.is_empty() {
                None
            } else {
                Some(StrCcsidOwned::from_vec(sub_name_buffer, CCSID(sts.SubName.VSCCSID)))
            },
            open_options: MQOO(sts.OpenOptions),
            sub_options: MQSO(sts.SubOptions),
        }
    }
}

#[derive(Debug, Clone)]
pub struct AsyncPutStat {
    pub warning: Option<MQCC>,
    pub reason: MQRC,
    pub put_success_count: MQLONG,
    pub put_warning_count: MQLONG,
    pub put_failure_count: MQLONG,
    pub object_type: MQOT,
    pub object_name: ObjectName,               // TODO: fix wrapper?
    pub object_qmgr_name: ObjectName,          // TODO: fix wrapper?
    pub resolved_object_name: ObjectName,      // TODO: fix wrapper?
    pub resolved_object_qmgr_name: ObjectName, // TODO: fix wrapper?
    pub object_string: Option<StrCcsidOwned>,
}

#[derive(Debug, Clone)]
pub struct ReconnectionStat {
    pub warning: Option<MQCC>,
    pub reason: MQRC,
    pub object_type: MQOT,
    pub object_name: ObjectName,      // TODO: fix wrapper?
    pub object_qmgr_name: ObjectName, // TODO: fix wrapper?
}

#[derive(Debug, Clone)]
pub struct ReconnectionErrorStat {
    pub warning: Option<MQCC>,
    pub reason: MQRC,
    pub object_type: MQOT,
    pub object_name: ObjectName,      // TODO: fix wrapper?
    pub object_qmgr_name: ObjectName, // TODO: fix wrapper?
    pub object_string: Option<StrCcsidOwned>,
    pub sub_name: Option<StrCcsidOwned>,
    pub open_options: MQOO,
    pub sub_options: MQSO,
}