1use crate::traits::*;
2use core::sync::atomic::*;
3
4impl AtomicallySized for usize {
5 type AtomicVersion = AtomicUsize;
6}
7
8impl Atomic<usize> for AtomicUsize {
9 fn new(val: usize) -> Self {
10 Self::new(val)
11 }
12 fn store(&self, val: usize, order: Ordering) {
13 self.store(val, order)
14 }
15 fn load(&self, order: Ordering) -> usize {
16 self.load(order)
17 }
18 fn swap(&self, val: usize, order: Ordering) -> usize {
19 self.swap(val, order)
20 }
21 fn get_mut(&mut self) -> &mut usize {
22 self.get_mut()
23 }
24 fn into_inner(self) -> usize {
25 self.into_inner()
26 }
27 fn compare_and_swap(&self, current: usize, new: usize, order: Ordering) -> usize {
28 self.compare_and_swap(current, new, order)
29 }
30 fn compare_exchange(
31 &self,
32 current: usize,
33 new: usize,
34 success: Ordering,
35 failure: Ordering,
36 ) -> Result<usize, usize> {
37 self.compare_exchange(current, new, success, failure)
38 }
39 fn compare_exchange_weak(
40 &self,
41 current: usize,
42 new: usize,
43 success: Ordering,
44 failure: Ordering,
45 ) -> Result<usize, usize> {
46 self.compare_exchange_weak(current, new, success, failure)
47 }
48}
49
50impl AtomicNumeric<usize> for AtomicUsize {
51 fn fetch_add(&self, val: usize, order: Ordering) -> usize {
52 self.fetch_add(val, order)
53 }
54 fn fetch_sub(&self, val: usize, order: Ordering) -> usize {
55 self.fetch_sub(val, order)
56 }
57}
58
59impl AtomicBitwise<usize> for AtomicUsize {
60 fn fetch_and(&self, val: usize, order: Ordering) -> usize {
61 self.fetch_and(val, order)
62 }
63 fn fetch_or(&self, val: usize, order: Ordering) -> usize {
64 self.fetch_or(val, order)
65 }
66 fn fetch_xor(&self, val: usize, order: Ordering) -> usize {
67 self.fetch_xor(val, order)
68 }
69 fn fetch_nand(&self, val: usize, order: Ordering) -> usize {
70 self.fetch_nand(val, order)
71 }
72}
73
74impl AtomicallySized for isize {
75 type AtomicVersion = AtomicIsize;
76}
77
78impl Atomic<isize> for AtomicIsize {
79 fn new(val: isize) -> Self {
80 Self::new(val)
81 }
82 fn store(&self, val: isize, order: Ordering) {
83 self.store(val, order)
84 }
85 fn load(&self, order: Ordering) -> isize {
86 self.load(order)
87 }
88 fn swap(&self, val: isize, order: Ordering) -> isize {
89 self.swap(val, order)
90 }
91 fn get_mut(&mut self) -> &mut isize {
92 self.get_mut()
93 }
94 fn into_inner(self) -> isize {
95 self.into_inner()
96 }
97 fn compare_and_swap(&self, current: isize, new: isize, order: Ordering) -> isize {
98 self.compare_and_swap(current, new, order)
99 }
100 fn compare_exchange(
101 &self,
102 current: isize,
103 new: isize,
104 success: Ordering,
105 failure: Ordering,
106 ) -> Result<isize, isize> {
107 self.compare_exchange(current, new, success, failure)
108 }
109 fn compare_exchange_weak(
110 &self,
111 current: isize,
112 new: isize,
113 success: Ordering,
114 failure: Ordering,
115 ) -> Result<isize, isize> {
116 self.compare_exchange_weak(current, new, success, failure)
117 }
118}
119
120impl AtomicNumeric<isize> for AtomicIsize {
121 fn fetch_add(&self, val: isize, order: Ordering) -> isize {
122 self.fetch_add(val, order)
123 }
124 fn fetch_sub(&self, val: isize, order: Ordering) -> isize {
125 self.fetch_sub(val, order)
126 }
127}
128
129impl AtomicBitwise<isize> for AtomicIsize {
130 fn fetch_and(&self, val: isize, order: Ordering) -> isize {
131 self.fetch_and(val, order)
132 }
133 fn fetch_or(&self, val: isize, order: Ordering) -> isize {
134 self.fetch_or(val, order)
135 }
136 fn fetch_xor(&self, val: isize, order: Ordering) -> isize {
137 self.fetch_xor(val, order)
138 }
139 fn fetch_nand(&self, val: isize, order: Ordering) -> isize {
140 self.fetch_nand(val, order)
141 }
142}
143
144impl AtomicallySized for u64 {
145 type AtomicVersion = AtomicU64;
146}
147
148impl Atomic<u64> for AtomicU64 {
149 fn new(val: u64) -> Self {
150 Self::new(val)
151 }
152 fn store(&self, val: u64, order: Ordering) {
153 self.store(val, order)
154 }
155 fn load(&self, order: Ordering) -> u64 {
156 self.load(order)
157 }
158 fn swap(&self, val: u64, order: Ordering) -> u64 {
159 self.swap(val, order)
160 }
161 fn get_mut(&mut self) -> &mut u64 {
162 self.get_mut()
163 }
164 fn into_inner(self) -> u64 {
165 self.into_inner()
166 }
167 fn compare_and_swap(&self, current: u64, new: u64, order: Ordering) -> u64 {
168 self.compare_and_swap(current, new, order)
169 }
170 fn compare_exchange(
171 &self,
172 current: u64,
173 new: u64,
174 success: Ordering,
175 failure: Ordering,
176 ) -> Result<u64, u64> {
177 self.compare_exchange(current, new, success, failure)
178 }
179 fn compare_exchange_weak(
180 &self,
181 current: u64,
182 new: u64,
183 success: Ordering,
184 failure: Ordering,
185 ) -> Result<u64, u64> {
186 self.compare_exchange_weak(current, new, success, failure)
187 }
188}
189
190impl AtomicNumeric<u64> for AtomicU64 {
191 fn fetch_add(&self, val: u64, order: Ordering) -> u64 {
192 self.fetch_add(val, order)
193 }
194 fn fetch_sub(&self, val: u64, order: Ordering) -> u64 {
195 self.fetch_sub(val, order)
196 }
197}
198
199impl AtomicBitwise<u64> for AtomicU64 {
200 fn fetch_and(&self, val: u64, order: Ordering) -> u64 {
201 self.fetch_and(val, order)
202 }
203 fn fetch_or(&self, val: u64, order: Ordering) -> u64 {
204 self.fetch_or(val, order)
205 }
206 fn fetch_xor(&self, val: u64, order: Ordering) -> u64 {
207 self.fetch_xor(val, order)
208 }
209 fn fetch_nand(&self, val: u64, order: Ordering) -> u64 {
210 self.fetch_nand(val, order)
211 }
212}
213
214impl AtomicallySized for i64 {
215 type AtomicVersion = AtomicI64;
216}
217
218impl Atomic<i64> for AtomicI64 {
219 fn new(val: i64) -> Self {
220 Self::new(val)
221 }
222 fn store(&self, val: i64, order: Ordering) {
223 self.store(val, order)
224 }
225 fn load(&self, order: Ordering) -> i64 {
226 self.load(order)
227 }
228 fn swap(&self, val: i64, order: Ordering) -> i64 {
229 self.swap(val, order)
230 }
231 fn get_mut(&mut self) -> &mut i64 {
232 self.get_mut()
233 }
234 fn into_inner(self) -> i64 {
235 self.into_inner()
236 }
237 fn compare_and_swap(&self, current: i64, new: i64, order: Ordering) -> i64 {
238 self.compare_and_swap(current, new, order)
239 }
240 fn compare_exchange(
241 &self,
242 current: i64,
243 new: i64,
244 success: Ordering,
245 failure: Ordering,
246 ) -> Result<i64, i64> {
247 self.compare_exchange(current, new, success, failure)
248 }
249 fn compare_exchange_weak(
250 &self,
251 current: i64,
252 new: i64,
253 success: Ordering,
254 failure: Ordering,
255 ) -> Result<i64, i64> {
256 self.compare_exchange_weak(current, new, success, failure)
257 }
258}
259
260impl AtomicNumeric<i64> for AtomicI64 {
261 fn fetch_add(&self, val: i64, order: Ordering) -> i64 {
262 self.fetch_add(val, order)
263 }
264 fn fetch_sub(&self, val: i64, order: Ordering) -> i64 {
265 self.fetch_sub(val, order)
266 }
267}
268
269impl AtomicBitwise<i64> for AtomicI64 {
270 fn fetch_and(&self, val: i64, order: Ordering) -> i64 {
271 self.fetch_and(val, order)
272 }
273 fn fetch_or(&self, val: i64, order: Ordering) -> i64 {
274 self.fetch_or(val, order)
275 }
276 fn fetch_xor(&self, val: i64, order: Ordering) -> i64 {
277 self.fetch_xor(val, order)
278 }
279 fn fetch_nand(&self, val: i64, order: Ordering) -> i64 {
280 self.fetch_nand(val, order)
281 }
282}
283
284impl AtomicallySized for u32 {
285 type AtomicVersion = AtomicU32;
286}
287
288impl Atomic<u32> for AtomicU32 {
289 fn new(val: u32) -> Self {
290 Self::new(val)
291 }
292 fn store(&self, val: u32, order: Ordering) {
293 self.store(val, order)
294 }
295 fn load(&self, order: Ordering) -> u32 {
296 self.load(order)
297 }
298 fn swap(&self, val: u32, order: Ordering) -> u32 {
299 self.swap(val, order)
300 }
301 fn get_mut(&mut self) -> &mut u32 {
302 self.get_mut()
303 }
304 fn into_inner(self) -> u32 {
305 self.into_inner()
306 }
307 fn compare_and_swap(&self, current: u32, new: u32, order: Ordering) -> u32 {
308 self.compare_and_swap(current, new, order)
309 }
310 fn compare_exchange(
311 &self,
312 current: u32,
313 new: u32,
314 success: Ordering,
315 failure: Ordering,
316 ) -> Result<u32, u32> {
317 self.compare_exchange(current, new, success, failure)
318 }
319 fn compare_exchange_weak(
320 &self,
321 current: u32,
322 new: u32,
323 success: Ordering,
324 failure: Ordering,
325 ) -> Result<u32, u32> {
326 self.compare_exchange_weak(current, new, success, failure)
327 }
328}
329
330impl AtomicNumeric<u32> for AtomicU32 {
331 fn fetch_add(&self, val: u32, order: Ordering) -> u32 {
332 self.fetch_add(val, order)
333 }
334 fn fetch_sub(&self, val: u32, order: Ordering) -> u32 {
335 self.fetch_sub(val, order)
336 }
337}
338
339impl AtomicBitwise<u32> for AtomicU32 {
340 fn fetch_and(&self, val: u32, order: Ordering) -> u32 {
341 self.fetch_and(val, order)
342 }
343 fn fetch_or(&self, val: u32, order: Ordering) -> u32 {
344 self.fetch_or(val, order)
345 }
346 fn fetch_xor(&self, val: u32, order: Ordering) -> u32 {
347 self.fetch_xor(val, order)
348 }
349 fn fetch_nand(&self, val: u32, order: Ordering) -> u32 {
350 self.fetch_nand(val, order)
351 }
352}
353
354impl AtomicallySized for i32 {
355 type AtomicVersion = AtomicI32;
356}
357
358impl Atomic<i32> for AtomicI32 {
359 fn new(val: i32) -> Self {
360 Self::new(val)
361 }
362 fn store(&self, val: i32, order: Ordering) {
363 self.store(val, order)
364 }
365 fn load(&self, order: Ordering) -> i32 {
366 self.load(order)
367 }
368 fn swap(&self, val: i32, order: Ordering) -> i32 {
369 self.swap(val, order)
370 }
371 fn get_mut(&mut self) -> &mut i32 {
372 self.get_mut()
373 }
374 fn into_inner(self) -> i32 {
375 self.into_inner()
376 }
377 fn compare_and_swap(&self, current: i32, new: i32, order: Ordering) -> i32 {
378 self.compare_and_swap(current, new, order)
379 }
380 fn compare_exchange(
381 &self,
382 current: i32,
383 new: i32,
384 success: Ordering,
385 failure: Ordering,
386 ) -> Result<i32, i32> {
387 self.compare_exchange(current, new, success, failure)
388 }
389 fn compare_exchange_weak(
390 &self,
391 current: i32,
392 new: i32,
393 success: Ordering,
394 failure: Ordering,
395 ) -> Result<i32, i32> {
396 self.compare_exchange_weak(current, new, success, failure)
397 }
398}
399
400impl AtomicNumeric<i32> for AtomicI32 {
401 fn fetch_add(&self, val: i32, order: Ordering) -> i32 {
402 self.fetch_add(val, order)
403 }
404 fn fetch_sub(&self, val: i32, order: Ordering) -> i32 {
405 self.fetch_sub(val, order)
406 }
407}
408
409impl AtomicBitwise<i32> for AtomicI32 {
410 fn fetch_and(&self, val: i32, order: Ordering) -> i32 {
411 self.fetch_and(val, order)
412 }
413 fn fetch_or(&self, val: i32, order: Ordering) -> i32 {
414 self.fetch_or(val, order)
415 }
416 fn fetch_xor(&self, val: i32, order: Ordering) -> i32 {
417 self.fetch_xor(val, order)
418 }
419 fn fetch_nand(&self, val: i32, order: Ordering) -> i32 {
420 self.fetch_nand(val, order)
421 }
422}
423
424impl AtomicallySized for u16 {
425 type AtomicVersion = AtomicU16;
426}
427
428impl Atomic<u16> for AtomicU16 {
429 fn new(val: u16) -> Self {
430 Self::new(val)
431 }
432 fn store(&self, val: u16, order: Ordering) {
433 self.store(val, order)
434 }
435 fn load(&self, order: Ordering) -> u16 {
436 self.load(order)
437 }
438 fn swap(&self, val: u16, order: Ordering) -> u16 {
439 self.swap(val, order)
440 }
441 fn get_mut(&mut self) -> &mut u16 {
442 self.get_mut()
443 }
444 fn into_inner(self) -> u16 {
445 self.into_inner()
446 }
447 fn compare_and_swap(&self, current: u16, new: u16, order: Ordering) -> u16 {
448 self.compare_and_swap(current, new, order)
449 }
450 fn compare_exchange(
451 &self,
452 current: u16,
453 new: u16,
454 success: Ordering,
455 failure: Ordering,
456 ) -> Result<u16, u16> {
457 self.compare_exchange(current, new, success, failure)
458 }
459 fn compare_exchange_weak(
460 &self,
461 current: u16,
462 new: u16,
463 success: Ordering,
464 failure: Ordering,
465 ) -> Result<u16, u16> {
466 self.compare_exchange_weak(current, new, success, failure)
467 }
468}
469
470impl AtomicNumeric<u16> for AtomicU16 {
471 fn fetch_add(&self, val: u16, order: Ordering) -> u16 {
472 self.fetch_add(val, order)
473 }
474 fn fetch_sub(&self, val: u16, order: Ordering) -> u16 {
475 self.fetch_sub(val, order)
476 }
477}
478
479impl AtomicBitwise<u16> for AtomicU16 {
480 fn fetch_and(&self, val: u16, order: Ordering) -> u16 {
481 self.fetch_and(val, order)
482 }
483 fn fetch_or(&self, val: u16, order: Ordering) -> u16 {
484 self.fetch_or(val, order)
485 }
486 fn fetch_xor(&self, val: u16, order: Ordering) -> u16 {
487 self.fetch_xor(val, order)
488 }
489 fn fetch_nand(&self, val: u16, order: Ordering) -> u16 {
490 self.fetch_nand(val, order)
491 }
492}
493
494impl AtomicallySized for i16 {
495 type AtomicVersion = AtomicI16;
496}
497
498impl Atomic<i16> for AtomicI16 {
499 fn new(val: i16) -> Self {
500 Self::new(val)
501 }
502 fn store(&self, val: i16, order: Ordering) {
503 self.store(val, order)
504 }
505 fn load(&self, order: Ordering) -> i16 {
506 self.load(order)
507 }
508 fn swap(&self, val: i16, order: Ordering) -> i16 {
509 self.swap(val, order)
510 }
511 fn get_mut(&mut self) -> &mut i16 {
512 self.get_mut()
513 }
514 fn into_inner(self) -> i16 {
515 self.into_inner()
516 }
517 fn compare_and_swap(&self, current: i16, new: i16, order: Ordering) -> i16 {
518 self.compare_and_swap(current, new, order)
519 }
520 fn compare_exchange(
521 &self,
522 current: i16,
523 new: i16,
524 success: Ordering,
525 failure: Ordering,
526 ) -> Result<i16, i16> {
527 self.compare_exchange(current, new, success, failure)
528 }
529 fn compare_exchange_weak(
530 &self,
531 current: i16,
532 new: i16,
533 success: Ordering,
534 failure: Ordering,
535 ) -> Result<i16, i16> {
536 self.compare_exchange_weak(current, new, success, failure)
537 }
538}
539
540impl AtomicNumeric<i16> for AtomicI16 {
541 fn fetch_add(&self, val: i16, order: Ordering) -> i16 {
542 self.fetch_add(val, order)
543 }
544 fn fetch_sub(&self, val: i16, order: Ordering) -> i16 {
545 self.fetch_sub(val, order)
546 }
547}
548
549impl AtomicBitwise<i16> for AtomicI16 {
550 fn fetch_and(&self, val: i16, order: Ordering) -> i16 {
551 self.fetch_and(val, order)
552 }
553 fn fetch_or(&self, val: i16, order: Ordering) -> i16 {
554 self.fetch_or(val, order)
555 }
556 fn fetch_xor(&self, val: i16, order: Ordering) -> i16 {
557 self.fetch_xor(val, order)
558 }
559 fn fetch_nand(&self, val: i16, order: Ordering) -> i16 {
560 self.fetch_nand(val, order)
561 }
562}
563
564impl AtomicallySized for u8 {
565 type AtomicVersion = AtomicU8;
566}
567
568impl Atomic<u8> for AtomicU8 {
569 fn new(val: u8) -> Self {
570 Self::new(val)
571 }
572 fn store(&self, val: u8, order: Ordering) {
573 self.store(val, order)
574 }
575 fn load(&self, order: Ordering) -> u8 {
576 self.load(order)
577 }
578 fn swap(&self, val: u8, order: Ordering) -> u8 {
579 self.swap(val, order)
580 }
581 fn get_mut(&mut self) -> &mut u8 {
582 self.get_mut()
583 }
584 fn into_inner(self) -> u8 {
585 self.into_inner()
586 }
587 fn compare_and_swap(&self, current: u8, new: u8, order: Ordering) -> u8 {
588 self.compare_and_swap(current, new, order)
589 }
590 fn compare_exchange(
591 &self,
592 current: u8,
593 new: u8,
594 success: Ordering,
595 failure: Ordering,
596 ) -> Result<u8, u8> {
597 self.compare_exchange(current, new, success, failure)
598 }
599 fn compare_exchange_weak(
600 &self,
601 current: u8,
602 new: u8,
603 success: Ordering,
604 failure: Ordering,
605 ) -> Result<u8, u8> {
606 self.compare_exchange_weak(current, new, success, failure)
607 }
608}
609
610impl AtomicNumeric<u8> for AtomicU8 {
611 fn fetch_add(&self, val: u8, order: Ordering) -> u8 {
612 self.fetch_add(val, order)
613 }
614 fn fetch_sub(&self, val: u8, order: Ordering) -> u8 {
615 self.fetch_sub(val, order)
616 }
617}
618
619impl AtomicBitwise<u8> for AtomicU8 {
620 fn fetch_and(&self, val: u8, order: Ordering) -> u8 {
621 self.fetch_and(val, order)
622 }
623 fn fetch_or(&self, val: u8, order: Ordering) -> u8 {
624 self.fetch_or(val, order)
625 }
626 fn fetch_xor(&self, val: u8, order: Ordering) -> u8 {
627 self.fetch_xor(val, order)
628 }
629 fn fetch_nand(&self, val: u8, order: Ordering) -> u8 {
630 self.fetch_nand(val, order)
631 }
632}
633
634impl AtomicallySized for i8 {
635 type AtomicVersion = AtomicI8;
636}
637
638impl Atomic<i8> for AtomicI8 {
639 fn new(val: i8) -> Self {
640 Self::new(val)
641 }
642 fn store(&self, val: i8, order: Ordering) {
643 self.store(val, order)
644 }
645 fn load(&self, order: Ordering) -> i8 {
646 self.load(order)
647 }
648 fn swap(&self, val: i8, order: Ordering) -> i8 {
649 self.swap(val, order)
650 }
651 fn get_mut(&mut self) -> &mut i8 {
652 self.get_mut()
653 }
654 fn into_inner(self) -> i8 {
655 self.into_inner()
656 }
657 fn compare_and_swap(&self, current: i8, new: i8, order: Ordering) -> i8 {
658 self.compare_and_swap(current, new, order)
659 }
660 fn compare_exchange(
661 &self,
662 current: i8,
663 new: i8,
664 success: Ordering,
665 failure: Ordering,
666 ) -> Result<i8, i8> {
667 self.compare_exchange(current, new, success, failure)
668 }
669 fn compare_exchange_weak(
670 &self,
671 current: i8,
672 new: i8,
673 success: Ordering,
674 failure: Ordering,
675 ) -> Result<i8, i8> {
676 self.compare_exchange_weak(current, new, success, failure)
677 }
678}
679
680impl AtomicNumeric<i8> for AtomicI8 {
681 fn fetch_add(&self, val: i8, order: Ordering) -> i8 {
682 self.fetch_add(val, order)
683 }
684 fn fetch_sub(&self, val: i8, order: Ordering) -> i8 {
685 self.fetch_sub(val, order)
686 }
687}
688
689impl AtomicBitwise<i8> for AtomicI8 {
690 fn fetch_and(&self, val: i8, order: Ordering) -> i8 {
691 self.fetch_and(val, order)
692 }
693 fn fetch_or(&self, val: i8, order: Ordering) -> i8 {
694 self.fetch_or(val, order)
695 }
696 fn fetch_xor(&self, val: i8, order: Ordering) -> i8 {
697 self.fetch_xor(val, order)
698 }
699 fn fetch_nand(&self, val: i8, order: Ordering) -> i8 {
700 self.fetch_nand(val, order)
701 }
702}
703
704impl AtomicallySized for bool {
705 type AtomicVersion = AtomicBool;
706}
707
708impl Atomic<bool> for AtomicBool {
709 fn new(val: bool) -> Self {
710 Self::new(val)
711 }
712 fn store(&self, val: bool, order: Ordering) {
713 self.store(val, order)
714 }
715 fn load(&self, order: Ordering) -> bool {
716 self.load(order)
717 }
718 fn swap(&self, val: bool, order: Ordering) -> bool {
719 self.swap(val, order)
720 }
721 fn get_mut(&mut self) -> &mut bool {
722 self.get_mut()
723 }
724 fn into_inner(self) -> bool {
725 self.into_inner()
726 }
727 fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool {
728 self.compare_and_swap(current, new, order)
729 }
730 fn compare_exchange(
731 &self,
732 current: bool,
733 new: bool,
734 success: Ordering,
735 failure: Ordering,
736 ) -> Result<bool, bool> {
737 self.compare_exchange(current, new, success, failure)
738 }
739 fn compare_exchange_weak(
740 &self,
741 current: bool,
742 new: bool,
743 success: Ordering,
744 failure: Ordering,
745 ) -> Result<bool, bool> {
746 self.compare_exchange_weak(current, new, success, failure)
747 }
748}
749
750impl AtomicBitwise<bool> for AtomicBool {
751 fn fetch_and(&self, val: bool, order: Ordering) -> bool {
752 self.fetch_and(val, order)
753 }
754 fn fetch_or(&self, val: bool, order: Ordering) -> bool {
755 self.fetch_or(val, order)
756 }
757 fn fetch_xor(&self, val: bool, order: Ordering) -> bool {
758 self.fetch_xor(val, order)
759 }
760 fn fetch_nand(&self, val: bool, order: Ordering) -> bool {
761 self.fetch_nand(val, order)
762 }
763}
764
765impl<T> AtomicallySized for *mut T {
766 type AtomicVersion = AtomicPtr<T>;
767}
768
769impl<T> Atomic<*mut T> for AtomicPtr<T> {
770 fn new(val: *mut T) -> Self {
771 Self::new(val)
772 }
773 fn store(&self, val: *mut T, order: Ordering) {
774 self.store(val, order)
775 }
776 fn load(&self, order: Ordering) -> *mut T {
777 self.load(order)
778 }
779 fn swap(&self, val: *mut T, order: Ordering) -> *mut T {
780 self.swap(val, order)
781 }
782 fn get_mut(&mut self) -> &mut *mut T {
783 self.get_mut()
784 }
785 fn into_inner(self) -> *mut T {
786 self.into_inner()
787 }
788 fn compare_and_swap(&self, current: *mut T, new: *mut T, order: Ordering) -> *mut T {
789 self.compare_and_swap(current, new, order)
790 }
791 fn compare_exchange(
792 &self,
793 current: *mut T,
794 new: *mut T,
795 success: Ordering,
796 failure: Ordering,
797 ) -> Result<*mut T, *mut T> {
798 self.compare_exchange(current, new, success, failure)
799 }
800 fn compare_exchange_weak(
801 &self,
802 current: *mut T,
803 new: *mut T,
804 success: Ordering,
805 failure: Ordering,
806 ) -> Result<*mut T, *mut T> {
807 self.compare_exchange_weak(current, new, success, failure)
808 }
809}