announce_std/
ops.rs

1//! announce mocks of `ops` traits. Generated from newer-type-std's copies.
2
3#[allow(unused_imports)]
4use announce::announce;
5
6/// announce mock of [`::core::ops::Deref`]: invoke `Deref!` to receive its definition.
7///
8/// The real trait is re-exported under the same path.
9#[announce(mock = ::core::ops::Deref)]
10pub trait Deref {
11    type Target: ?::core::marker::Sized;
12    fn deref(&self) -> &Self::Target;
13}
14
15#[doc(no_inline)]
16pub use ::core::ops::Deref;
17
18/// announce mock of [`::core::ops::DerefMut`]: invoke `DerefMut!` to receive its definition.
19///
20/// The real trait is re-exported under the same path.
21#[announce(mock = ::core::ops::DerefMut)]
22pub trait DerefMut: ::core::ops::Deref {
23    fn deref_mut(&mut self) -> &mut Self::Target;
24}
25
26#[doc(no_inline)]
27pub use ::core::ops::DerefMut;
28
29/// announce mock of [`::core::ops::Index`]: invoke `Index!` to receive its definition.
30///
31/// The real trait is re-exported under the same path.
32#[announce(mock = ::core::ops::Index)]
33pub trait Index<Idx: ?::core::marker::Sized> {
34    type Output: ?::core::marker::Sized;
35    fn index(&self, index: Idx) -> &Self::Output;
36}
37
38#[doc(no_inline)]
39pub use ::core::ops::Index;
40
41/// announce mock of [`::core::ops::IndexMut`]: invoke `IndexMut!` to receive its definition.
42///
43/// The real trait is re-exported under the same path.
44#[announce(mock = ::core::ops::IndexMut)]
45pub trait IndexMut<Idx: ?::core::marker::Sized>: ::core::ops::Index<Idx> {
46    fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
47}
48
49#[doc(no_inline)]
50pub use ::core::ops::IndexMut;
51
52/// announce mock of [`::core::ops::Not`]: invoke `Not!` to receive its definition.
53///
54/// The real trait is re-exported under the same path.
55#[announce(mock = ::core::ops::Not)]
56pub trait Not {
57    type Output;
58    fn not(self) -> Self::Output;
59}
60
61#[doc(no_inline)]
62pub use ::core::ops::Not;
63
64/// announce mock of [`::core::ops::BitAnd`]: invoke `BitAnd!` to receive its definition.
65///
66/// The real trait is re-exported under the same path.
67#[announce(mock = ::core::ops::BitAnd)]
68pub trait BitAnd<Rhs = Self> {
69    type Output;
70    fn bitand(self, rhs: Rhs) -> Self::Output;
71}
72
73#[doc(no_inline)]
74pub use ::core::ops::BitAnd;
75
76/// announce mock of [`::core::ops::BitOr`]: invoke `BitOr!` to receive its definition.
77///
78/// The real trait is re-exported under the same path.
79#[announce(mock = ::core::ops::BitOr)]
80pub trait BitOr<Rhs = Self> {
81    type Output;
82    fn bitor(self, rhs: Rhs) -> Self::Output;
83}
84
85#[doc(no_inline)]
86pub use ::core::ops::BitOr;
87
88/// announce mock of [`::core::ops::BitXor`]: invoke `BitXor!` to receive its definition.
89///
90/// The real trait is re-exported under the same path.
91#[announce(mock = ::core::ops::BitXor)]
92pub trait BitXor<Rhs = Self> {
93    type Output;
94    fn bitxor(self, rhs: Rhs) -> Self::Output;
95}
96
97#[doc(no_inline)]
98pub use ::core::ops::BitXor;
99
100/// announce mock of [`::core::ops::Shl`]: invoke `Shl!` to receive its definition.
101///
102/// The real trait is re-exported under the same path.
103#[announce(mock = ::core::ops::Shl)]
104pub trait Shl<Rhs = Self> {
105    type Output;
106    fn shl(self, rhs: Rhs) -> Self::Output;
107}
108
109#[doc(no_inline)]
110pub use ::core::ops::Shl;
111
112/// announce mock of [`::core::ops::Shr`]: invoke `Shr!` to receive its definition.
113///
114/// The real trait is re-exported under the same path.
115#[announce(mock = ::core::ops::Shr)]
116pub trait Shr<Rhs = Self> {
117    type Output;
118    fn shr(self, rhs: Rhs) -> Self::Output;
119}
120
121#[doc(no_inline)]
122pub use ::core::ops::Shr;
123
124/// announce mock of [`::core::ops::BitAndAssign`]: invoke `BitAndAssign!` to receive its definition.
125///
126/// The real trait is re-exported under the same path.
127#[announce(mock = ::core::ops::BitAndAssign)]
128pub trait BitAndAssign<Rhs = Self> {
129    fn bitand_assign(&mut self, rhs: Rhs);
130}
131
132#[doc(no_inline)]
133pub use ::core::ops::BitAndAssign;
134
135/// announce mock of [`::core::ops::BitOrAssign`]: invoke `BitOrAssign!` to receive its definition.
136///
137/// The real trait is re-exported under the same path.
138#[announce(mock = ::core::ops::BitOrAssign)]
139pub trait BitOrAssign<Rhs = Self> {
140    fn bitor_assign(&mut self, rhs: Rhs);
141}
142
143#[doc(no_inline)]
144pub use ::core::ops::BitOrAssign;
145
146/// announce mock of [`::core::ops::BitXorAssign`]: invoke `BitXorAssign!` to receive its definition.
147///
148/// The real trait is re-exported under the same path.
149#[announce(mock = ::core::ops::BitXorAssign)]
150pub trait BitXorAssign<Rhs = Self> {
151    fn bitxor_assign(&mut self, rhs: Rhs);
152}
153
154#[doc(no_inline)]
155pub use ::core::ops::BitXorAssign;
156
157/// announce mock of [`::core::ops::ShlAssign`]: invoke `ShlAssign!` to receive its definition.
158///
159/// The real trait is re-exported under the same path.
160#[announce(mock = ::core::ops::ShlAssign)]
161pub trait ShlAssign<Rhs = Self> {
162    fn shl_assign(&mut self, rhs: Rhs);
163}
164
165#[doc(no_inline)]
166pub use ::core::ops::ShlAssign;
167
168/// announce mock of [`::core::ops::ShrAssign`]: invoke `ShrAssign!` to receive its definition.
169///
170/// The real trait is re-exported under the same path.
171#[announce(mock = ::core::ops::ShrAssign)]
172pub trait ShrAssign<Rhs = Self> {
173    fn shr_assign(&mut self, rhs: Rhs);
174}
175
176#[doc(no_inline)]
177pub use ::core::ops::ShrAssign;
178
179/// announce mock of [`::core::ops::Add`]: invoke `Add!` to receive its definition.
180///
181/// The real trait is re-exported under the same path.
182#[announce(mock = ::core::ops::Add)]
183pub trait Add<Rhs = Self> {
184    type Output;
185    fn add(self, rhs: Rhs) -> Self::Output;
186}
187
188#[doc(no_inline)]
189pub use ::core::ops::Add;
190
191/// announce mock of [`::core::ops::Sub`]: invoke `Sub!` to receive its definition.
192///
193/// The real trait is re-exported under the same path.
194#[announce(mock = ::core::ops::Sub)]
195pub trait Sub<Rhs = Self> {
196    type Output;
197    fn sub(self, rhs: Rhs) -> Self::Output;
198}
199
200#[doc(no_inline)]
201pub use ::core::ops::Sub;
202
203/// announce mock of [`::core::ops::Mul`]: invoke `Mul!` to receive its definition.
204///
205/// The real trait is re-exported under the same path.
206#[announce(mock = ::core::ops::Mul)]
207pub trait Mul<Rhs = Self> {
208    type Output;
209    fn mul(self, rhs: Rhs) -> Self::Output;
210}
211
212#[doc(no_inline)]
213pub use ::core::ops::Mul;
214
215/// announce mock of [`::core::ops::Div`]: invoke `Div!` to receive its definition.
216///
217/// The real trait is re-exported under the same path.
218#[announce(mock = ::core::ops::Div)]
219pub trait Div<Rhs = Self> {
220    type Output;
221    fn div(self, rhs: Rhs) -> Self::Output;
222}
223
224#[doc(no_inline)]
225pub use ::core::ops::Div;
226
227/// announce mock of [`::core::ops::Rem`]: invoke `Rem!` to receive its definition.
228///
229/// The real trait is re-exported under the same path.
230#[announce(mock = ::core::ops::Rem)]
231pub trait Rem<Rhs = Self> {
232    type Output;
233    fn rem(self, rhs: Rhs) -> Self::Output;
234}
235
236#[doc(no_inline)]
237pub use ::core::ops::Rem;
238
239/// announce mock of [`::core::ops::Neg`]: invoke `Neg!` to receive its definition.
240///
241/// The real trait is re-exported under the same path.
242#[announce(mock = ::core::ops::Neg)]
243pub trait Neg {
244    type Output;
245    fn neg(self) -> Self::Output;
246}
247
248#[doc(no_inline)]
249pub use ::core::ops::Neg;
250
251/// announce mock of [`::core::ops::AddAssign`]: invoke `AddAssign!` to receive its definition.
252///
253/// The real trait is re-exported under the same path.
254#[announce(mock = ::core::ops::AddAssign)]
255pub trait AddAssign<Rhs = Self> {
256    fn add_assign(&mut self, rhs: Rhs);
257}
258
259#[doc(no_inline)]
260pub use ::core::ops::AddAssign;
261
262/// announce mock of [`::core::ops::SubAssign`]: invoke `SubAssign!` to receive its definition.
263///
264/// The real trait is re-exported under the same path.
265#[announce(mock = ::core::ops::SubAssign)]
266pub trait SubAssign<Rhs = Self> {
267    fn sub_assign(&mut self, rhs: Rhs);
268}
269
270#[doc(no_inline)]
271pub use ::core::ops::SubAssign;
272
273/// announce mock of [`::core::ops::MulAssign`]: invoke `MulAssign!` to receive its definition.
274///
275/// The real trait is re-exported under the same path.
276#[announce(mock = ::core::ops::MulAssign)]
277pub trait MulAssign<Rhs = Self> {
278    fn mul_assign(&mut self, rhs: Rhs);
279}
280
281#[doc(no_inline)]
282pub use ::core::ops::MulAssign;
283
284/// announce mock of [`::core::ops::DivAssign`]: invoke `DivAssign!` to receive its definition.
285///
286/// The real trait is re-exported under the same path.
287#[announce(mock = ::core::ops::DivAssign)]
288pub trait DivAssign<Rhs = Self> {
289    fn div_assign(&mut self, rhs: Rhs);
290}
291
292#[doc(no_inline)]
293pub use ::core::ops::DivAssign;
294
295/// announce mock of [`::core::ops::RemAssign`]: invoke `RemAssign!` to receive its definition.
296///
297/// The real trait is re-exported under the same path.
298#[announce(mock = ::core::ops::RemAssign)]
299pub trait RemAssign<Rhs = Self> {
300    fn rem_assign(&mut self, rhs: Rhs);
301}
302
303#[doc(no_inline)]
304pub use ::core::ops::RemAssign;
announce_std/ops.rs

announce_std/
ops.rs
