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

use std::fmt::Display;

use crate::{constants, types::MQCFOP};

#[derive(Debug, Clone, Copy, Eq)]
pub struct Filter<T> {
    pub operator: MQCFOP,
    pub value: T,
}

impl<A, B> PartialEq<Filter<A>> for Filter<B>
where
    B: PartialEq<A>,
{
    fn eq(&self, other: &Filter<A>) -> bool {
        self.operator == other.operator && self.value == other.value
    }
}

impl<T> Filter<T> {
    pub const fn value(&self) -> &T {
        &self.value
    }

    pub const fn operator(&self) -> MQCFOP {
        let &Self { operator, .. } = self;
        operator
    }

    pub const fn new(value: T, operator: MQCFOP) -> Self {
        Self { operator, value }
    }

    pub const fn less(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_LESS,
            value,
        }
    }

    pub const fn equal(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_EQUAL,
            value,
        }
    }

    pub const fn not_greater(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_NOT_GREATER,
            value,
        }
    }

    pub const fn greater(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_GREATER,
            value,
        }
    }

    pub const fn not_equal(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_NOT_EQUAL,
            value,
        }
    }

    pub const fn not_less(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_NOT_LESS,
            value,
        }
    }

    pub const fn contains(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_CONTAINS,
            value,
        }
    }

    pub const fn excludes(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_EXCLUDES,
            value,
        }
    }

    pub const fn like(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_LIKE,
            value,
        }
    }

    pub const fn not_like(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_NOT_LIKE,
            value,
        }
    }

    pub const fn contains_gen(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_CONTAINS_GEN,
            value,
        }
    }

    pub const fn excludes_gen(value: T) -> Self {
        Self {
            operator: constants::MQCFOP_EXCLUDES_GEN,
            value,
        }
    }
}

impl<T> Filter<Vec<T>> {
    #[must_use]
    pub const fn as_slice(&self) -> Filter<&[T]> {
        Filter {
            operator: self.operator,
            value: self.value.as_slice(),
        }
    }
}

impl<T: Display> Display for Filter<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{} <{}>", self.value, self.operator)
    }
}