croaring_mw/bitmap/ops.rs
1use std::fmt;
2use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Sub, SubAssign};
3
4use super::{ffi, Bitmap};
5
6impl fmt::Debug for Bitmap {
7 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
8 write!(f, "Bitmap<{:?}>", self.to_vec())
9 }
10}
11
12impl PartialEq for Bitmap {
13 #[inline]
14 fn eq(&self, other: &Bitmap) -> bool {
15 unsafe { ffi::roaring_bitmap_equals(self.bitmap, other.bitmap) }
16 }
17}
18
19impl Clone for Bitmap {
20 /// Create a copy of a Bitmap
21 /// # Examples
22 ///
23 /// ```
24 /// use croaring::Bitmap;
25 ///
26 /// let mut bitmap1 = Bitmap::create();
27 /// bitmap1.add(11);
28 ///
29 /// let bitmap2 = bitmap1.clone();
30 ///
31 /// assert_eq!(bitmap1, bitmap2);
32 /// ```
33 #[inline]
34 fn clone(&self) -> Bitmap {
35 unsafe {
36 Bitmap {
37 bitmap: ffi::roaring_bitmap_copy(self.bitmap),
38 }
39 }
40 }
41}
42
43impl Drop for Bitmap {
44 fn drop(&mut self) {
45 unsafe { ffi::roaring_bitmap_free(self.bitmap) }
46 }
47}
48
49impl BitAnd for Bitmap {
50 type Output = Bitmap;
51
52 /// Syntactic sugar for `.and`
53 ///
54 /// # Examples
55 ///
56 /// ```
57 /// use croaring::Bitmap;
58 ///
59 /// let mut bitmap1 = Bitmap::create();
60 /// bitmap1.add(1);
61 ///
62 /// let mut bitmap2 = Bitmap::create();
63 /// bitmap2.add(1);
64 /// bitmap2.add(2);
65 ///
66 /// let bitmap3 = bitmap1 & bitmap2;
67 ///
68 /// assert!(bitmap3.contains(1));
69 /// assert!(!bitmap3.contains(2));
70 /// ```
71 #[inline]
72 fn bitand(self, other: Bitmap) -> Bitmap {
73 self.and(&other)
74 }
75}
76
77impl<'a> BitAnd<&'a Bitmap> for Bitmap {
78 type Output = Bitmap;
79
80 /// Syntactic sugar for `.and`
81 ///
82 /// # Examples
83 ///
84 /// ```
85 /// use croaring::Bitmap;
86 ///
87 /// let mut bitmap1 = Bitmap::create();
88 /// bitmap1.add(1);
89 ///
90 /// let mut bitmap2 = Bitmap::create();
91 /// bitmap2.add(1);
92 /// bitmap2.add(2);
93 ///
94 /// let bitmap3 = bitmap1 & &bitmap2;
95 ///
96 /// assert!(bitmap3.contains(1));
97 /// assert!(!bitmap3.contains(2));
98 /// ```
99 #[inline]
100 fn bitand(self, other: &'a Bitmap) -> Bitmap {
101 self.and(&other)
102 }
103}
104
105impl<'a, 'b> BitAnd<&'a Bitmap> for &'b Bitmap {
106 type Output = Bitmap;
107
108 /// Syntactic sugar for `.and`
109 ///
110 /// # Examples
111 ///
112 /// ```
113 /// use croaring::Bitmap;
114 ///
115 /// let mut bitmap1: Bitmap = Bitmap::create();
116 /// bitmap1.add(1);
117 ///
118 /// let mut bitmap2 = Bitmap::create();
119 /// bitmap2.add(1);
120 /// bitmap2.add(2);
121 ///
122 /// let bitmap3 = &bitmap1 & &bitmap2;
123 ///
124 /// assert!(bitmap3.contains(1));
125 /// assert!(!bitmap3.contains(2));
126 /// ```
127 #[inline]
128 fn bitand(self, other: &'a Bitmap) -> Bitmap {
129 self.and(&other)
130 }
131}
132
133impl BitAndAssign for Bitmap {
134 /// Syntactic sugar for `.and_inplace`
135 ///
136 /// # Examples
137 ///
138 /// ```
139 /// use croaring::Bitmap;
140 ///
141 /// let mut bitmap1 = Bitmap::create();
142 /// bitmap1.add(15);
143 ///
144 /// let mut bitmap2 = Bitmap::create();
145 /// bitmap2.add(25);
146 ///
147 /// let mut bitmap3 = Bitmap::create();
148 /// bitmap3.add(15);
149 ///
150 /// let mut bitmap4 = Bitmap::create();
151 /// bitmap4.add(15);
152 /// bitmap4.add(25);
153 ///
154 /// bitmap1 &= bitmap2;
155 ///
156 /// assert!(bitmap1.cardinality() == 0);
157 /// assert!(!bitmap1.contains(15));
158 /// assert!(!bitmap1.contains(25));
159 ///
160 /// bitmap3 &= bitmap4;
161 ///
162 /// assert!(bitmap3.cardinality() == 1);
163 /// assert!(bitmap3.contains(15));
164 /// assert!(!bitmap3.contains(25));
165 /// ```
166 #[inline]
167 fn bitand_assign(&mut self, other: Bitmap) {
168 self.and_inplace(&other);
169 }
170}
171
172impl BitOr for Bitmap {
173 type Output = Bitmap;
174
175 /// Syntatic sugar for `.or`
176 ///
177 /// # Examples
178 ///
179 /// ```
180 /// use croaring::Bitmap;
181 ///
182 /// let mut bitmap1 = Bitmap::create();
183 /// bitmap1.add(15);
184 ///
185 /// let mut bitmap2 = Bitmap::create();
186 /// bitmap2.add(25);
187 ///
188 /// let bitmap3 = bitmap1 | bitmap2;
189 ///
190 /// assert!(bitmap3.cardinality() == 2);
191 /// assert!(bitmap3.contains(15));
192 /// assert!(bitmap3.contains(25));
193 /// ```
194 #[inline]
195 fn bitor(self, other: Bitmap) -> Bitmap {
196 self.or(&other)
197 }
198}
199
200impl<'a> BitOr<&'a Bitmap> for Bitmap {
201 type Output = Bitmap;
202
203 /// Syntatic sugar for `.or`
204 ///
205 /// # Examples
206 ///
207 /// ```
208 /// use croaring::Bitmap;
209 ///
210 /// let mut bitmap1 = Bitmap::create();
211 /// bitmap1.add(15);
212 ///
213 /// let mut bitmap2 = Bitmap::create();
214 /// bitmap2.add(25);
215 ///
216 /// let bitmap3 = bitmap1 | &bitmap2;
217 ///
218 /// assert!(bitmap3.cardinality() == 2);
219 /// assert!(bitmap3.contains(15));
220 /// assert!(bitmap3.contains(25));
221 /// ```
222 #[inline]
223 fn bitor(self, other: &'a Bitmap) -> Bitmap {
224 self.or(&other)
225 }
226}
227
228impl<'a, 'b> BitOr<&'a Bitmap> for &'b Bitmap {
229 type Output = Bitmap;
230
231 /// Syntatic sugar for `.or`
232 ///
233 /// # Examples
234 ///
235 /// ```
236 /// use croaring::Bitmap;
237 ///
238 /// let mut bitmap1 = Bitmap::create();
239 /// bitmap1.add(15);
240 ///
241 /// let mut bitmap2 = Bitmap::create();
242 /// bitmap2.add(25);
243 ///
244 /// let bitmap3 = &bitmap1 | &bitmap2;
245 ///
246 /// assert!(bitmap3.cardinality() == 2);
247 /// assert!(bitmap3.contains(15));
248 /// assert!(bitmap3.contains(25));
249 /// ```
250 #[inline]
251 fn bitor(self, other: &'a Bitmap) -> Bitmap {
252 self.or(&other)
253 }
254}
255
256impl BitOrAssign for Bitmap {
257 /// Syntatic sugar for `.or_inplace`
258 ///
259 /// # Examples
260 ///
261 /// ```
262 /// use croaring::Bitmap;
263 ///
264 /// let mut bitmap1 = Bitmap::create();
265 /// bitmap1.add(15);
266 ///
267 /// let mut bitmap2 = Bitmap::create();
268 /// bitmap2.add(25);
269 ///
270 /// bitmap1 |= bitmap2;
271 ///
272 /// assert!(bitmap1.cardinality() == 2);
273 /// assert!(bitmap1.contains(15));
274 /// assert!(bitmap1.contains(25));
275 /// ```
276 #[inline]
277 fn bitor_assign(&mut self, other: Bitmap) {
278 self.or_inplace(&other)
279 }
280}
281
282impl BitXor for Bitmap {
283 type Output = Bitmap;
284
285 /// Syntatic sugar for `.xor`
286 ///
287 /// # Examples
288 ///
289 /// ```
290 /// use croaring::Bitmap;
291 ///
292 /// let mut bitmap1 = Bitmap::create();
293 /// bitmap1.add(15);
294 /// bitmap1.add(25);
295 ///
296 /// let mut bitmap2 = Bitmap::create();
297 /// bitmap2.add(25);
298 /// bitmap2.add(35);
299 ///
300 /// let bitmap3 = bitmap1 ^ bitmap2;
301 ///
302 /// assert!(bitmap3.cardinality() == 2);
303 /// assert!(bitmap3.contains(15));
304 /// assert!(!bitmap3.contains(25));
305 /// assert!(bitmap3.contains(35));
306 /// ```
307 #[inline]
308 fn bitxor(self, other: Bitmap) -> Bitmap {
309 self.xor(&other)
310 }
311}
312
313impl<'a> BitXor<&'a Bitmap> for Bitmap {
314 type Output = Bitmap;
315
316 /// Syntatic sugar for `.xor`
317 ///
318 /// # Examples
319 ///
320 /// ```
321 /// use croaring::Bitmap;
322 ///
323 /// let mut bitmap1 = Bitmap::create();
324 /// bitmap1.add(15);
325 /// bitmap1.add(25);
326 ///
327 /// let mut bitmap2 = Bitmap::create();
328 /// bitmap2.add(25);
329 /// bitmap2.add(35);
330 ///
331 /// let bitmap3 = bitmap1 ^ &bitmap2;
332 ///
333 /// assert!(bitmap3.cardinality() == 2);
334 /// assert!(bitmap3.contains(15));
335 /// assert!(!bitmap3.contains(25));
336 /// assert!(bitmap3.contains(35));
337 /// ```
338 #[inline]
339 fn bitxor(self, other: &'a Bitmap) -> Bitmap {
340 self.xor(&other)
341 }
342}
343
344impl<'a, 'b> BitXor<&'a Bitmap> for &'b Bitmap {
345 type Output = Bitmap;
346
347 /// Syntatic sugar for `.xor`
348 ///
349 /// # Examples
350 ///
351 /// ```
352 /// use croaring::Bitmap;
353 ///
354 /// let mut bitmap1 = Bitmap::create();
355 /// bitmap1.add(15);
356 /// bitmap1.add(25);
357 ///
358 /// let mut bitmap2 = Bitmap::create();
359 /// bitmap2.add(25);
360 /// bitmap2.add(35);
361 ///
362 /// let bitmap3 = &bitmap1 ^ &bitmap2;
363 ///
364 /// assert!(bitmap3.cardinality() == 2);
365 /// assert!(bitmap3.contains(15));
366 /// assert!(!bitmap3.contains(25));
367 /// assert!(bitmap3.contains(35));
368 /// ```
369 #[inline]
370 fn bitxor(self, other: &'a Bitmap) -> Bitmap {
371 self.xor(&other)
372 }
373}
374
375impl BitXorAssign for Bitmap {
376 /// Syntatic sugar for `.xor_inplace`
377 ///
378 /// # Examples
379 ///
380 /// ```
381 /// use croaring::Bitmap;
382 ///
383 /// let mut bitmap1 = Bitmap::create();
384 /// bitmap1.add(15);
385 /// bitmap1.add(25);
386 ///
387 /// let mut bitmap2 = Bitmap::create();
388 /// bitmap2.add(25);
389 /// bitmap2.add(35);
390 ///
391 /// bitmap1 ^= bitmap2;
392 ///
393 /// assert!(bitmap1.cardinality() == 2);
394 /// assert!(bitmap1.contains(15));
395 /// assert!(!bitmap1.contains(25));
396 /// assert!(bitmap1.contains(35));
397 /// ```
398 #[inline]
399 fn bitxor_assign(&mut self, other: Bitmap) {
400 self.xor_inplace(&other)
401 }
402}
403
404impl Sub for Bitmap {
405 type Output = Bitmap;
406
407 /// Syntatic sugar for `.andnot`
408 ///
409 /// # Examples
410 ///
411 /// ```
412 /// use croaring::Bitmap;
413 ///
414 /// let mut bitmap1 = Bitmap::create();
415 ///
416 /// bitmap1.add(15);
417 /// bitmap1.add(25);
418 ///
419 /// let mut bitmap2 = Bitmap::create();
420 ///
421 /// bitmap2.add(25);
422 /// bitmap2.add(35);
423 ///
424 /// let bitmap3 = bitmap1 - bitmap2;
425 ///
426 /// assert_eq!(bitmap3.cardinality(), 1);
427 /// assert!(bitmap3.contains(15));
428 /// assert!(!bitmap3.contains(25));
429 /// assert!(!bitmap3.contains(35));
430 /// ```
431 #[inline]
432 fn sub(self, other: Bitmap) -> Bitmap {
433 self.andnot(&other)
434 }
435}
436
437impl<'a> Sub<&'a Bitmap> for Bitmap {
438 type Output = Bitmap;
439
440 /// Syntatic sugar for `.andnot`
441 ///
442 /// # Examples
443 ///
444 /// ```
445 /// use croaring::Bitmap;
446 ///
447 /// let mut bitmap1 = Bitmap::create();
448 ///
449 /// bitmap1.add(15);
450 /// bitmap1.add(25);
451 ///
452 /// let mut bitmap2 = Bitmap::create();
453 ///
454 /// bitmap2.add(25);
455 /// bitmap2.add(35);
456 ///
457 /// let bitmap3 = bitmap1 - &bitmap2;
458 ///
459 /// assert_eq!(bitmap3.cardinality(), 1);
460 /// assert!(bitmap3.contains(15));
461 /// assert!(!bitmap3.contains(25));
462 /// assert!(!bitmap3.contains(35));
463 /// ```
464 #[inline]
465 fn sub(self, other: &'a Bitmap) -> Bitmap {
466 self.andnot(&other)
467 }
468}
469
470impl<'a, 'b> Sub<&'a Bitmap> for &'b Bitmap {
471 type Output = Bitmap;
472
473 /// Syntatic sugar for `.andnot`
474 ///
475 /// # Examples
476 ///
477 /// ```
478 /// use croaring::Bitmap;
479 ///
480 /// let mut bitmap1 = Bitmap::create();
481 ///
482 /// bitmap1.add(15);
483 /// bitmap1.add(25);
484 ///
485 /// let mut bitmap2 = Bitmap::create();
486 ///
487 /// bitmap2.add(25);
488 /// bitmap2.add(35);
489 ///
490 /// let bitmap3 = &bitmap1 - &bitmap2;
491 ///
492 /// assert_eq!(bitmap3.cardinality(), 1);
493 /// assert!(bitmap3.contains(15));
494 /// assert!(!bitmap3.contains(25));
495 /// assert!(!bitmap3.contains(35));
496 /// ```
497 #[inline]
498 fn sub(self, other: &'a Bitmap) -> Bitmap {
499 self.andnot(&other)
500 }
501}
502
503impl SubAssign for Bitmap {
504 /// Syntatic sugar for `.andnot_inplace`
505 ///
506 /// # Examples
507 ///
508 /// ```
509 /// use croaring::Bitmap;
510 ///
511 /// let mut bitmap1 = Bitmap::create();
512 ///
513 /// bitmap1.add(15);
514 /// bitmap1.add(25);
515 ///
516 /// let mut bitmap2 = Bitmap::create();
517 ///
518 /// bitmap2.add(25);
519 /// bitmap2.add(35);
520 ///
521 /// bitmap1.andnot_inplace(&bitmap2);
522 ///
523 /// assert_eq!(bitmap1.cardinality(), 1);
524 /// assert!(bitmap1.contains(15));
525 /// assert!(!bitmap1.contains(25));
526 /// assert!(!bitmap1.contains(35));
527 /// ```
528 #[inline]
529 fn sub_assign(&mut self, other: Bitmap) {
530 self.andnot_inplace(&other)
531 }
532}