@@ -415,6 +415,7 @@ impl AtomicIsize {
415
415
/// let atomic_forty_two = AtomicIsize::new(42);
416
416
/// ```
417
417
#[ inline]
418
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
418
419
pub fn new ( v : isize ) -> AtomicIsize {
419
420
AtomicIsize { v : UnsafeCell :: new ( v) }
420
421
}
@@ -437,6 +438,7 @@ impl AtomicIsize {
437
438
/// let value = some_isize.load(Ordering::Relaxed);
438
439
/// ```
439
440
#[ inline]
441
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
440
442
pub fn load ( & self , order : Ordering ) -> isize {
441
443
unsafe { atomic_load ( self . v . get ( ) , order) }
442
444
}
@@ -459,6 +461,7 @@ impl AtomicIsize {
459
461
///
460
462
/// Panics if `order` is `Acquire` or `AcqRel`.
461
463
#[ inline]
464
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
462
465
pub fn store ( & self , val : isize , order : Ordering ) {
463
466
unsafe { atomic_store ( self . v . get ( ) , val, order) ; }
464
467
}
@@ -477,6 +480,7 @@ impl AtomicIsize {
477
480
/// let value = some_isize.swap(10, Ordering::Relaxed);
478
481
/// ```
479
482
#[ inline]
483
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
480
484
pub fn swap ( & self , val : isize , order : Ordering ) -> isize {
481
485
unsafe { atomic_swap ( self . v . get ( ) , val, order) }
482
486
}
@@ -498,6 +502,7 @@ impl AtomicIsize {
498
502
/// let value = some_isize.compare_and_swap(5, 10, Ordering::Relaxed);
499
503
/// ```
500
504
#[ inline]
505
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
501
506
pub fn compare_and_swap ( & self , old : isize , new : isize , order : Ordering ) -> isize {
502
507
unsafe { atomic_compare_and_swap ( self . v . get ( ) , old, new, order) }
503
508
}
@@ -514,6 +519,7 @@ impl AtomicIsize {
514
519
/// assert_eq!(10, foo.load(Ordering::SeqCst));
515
520
/// ```
516
521
#[ inline]
522
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
517
523
pub fn fetch_add ( & self , val : isize , order : Ordering ) -> isize {
518
524
unsafe { atomic_add ( self . v . get ( ) , val, order) }
519
525
}
@@ -530,6 +536,7 @@ impl AtomicIsize {
530
536
/// assert_eq!(-10, foo.load(Ordering::SeqCst));
531
537
/// ```
532
538
#[ inline]
539
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
533
540
pub fn fetch_sub ( & self , val : isize , order : Ordering ) -> isize {
534
541
unsafe { atomic_sub ( self . v . get ( ) , val, order) }
535
542
}
@@ -545,6 +552,7 @@ impl AtomicIsize {
545
552
/// assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst));
546
553
/// assert_eq!(0b100001, foo.load(Ordering::SeqCst));
547
554
#[ inline]
555
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
548
556
pub fn fetch_and ( & self , val : isize , order : Ordering ) -> isize {
549
557
unsafe { atomic_and ( self . v . get ( ) , val, order) }
550
558
}
@@ -560,6 +568,7 @@ impl AtomicIsize {
560
568
/// assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst));
561
569
/// assert_eq!(0b111111, foo.load(Ordering::SeqCst));
562
570
#[ inline]
571
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
563
572
pub fn fetch_or ( & self , val : isize , order : Ordering ) -> isize {
564
573
unsafe { atomic_or ( self . v . get ( ) , val, order) }
565
574
}
@@ -575,6 +584,7 @@ impl AtomicIsize {
575
584
/// assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst));
576
585
/// assert_eq!(0b011110, foo.load(Ordering::SeqCst));
577
586
#[ inline]
587
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
578
588
pub fn fetch_xor ( & self , val : isize , order : Ordering ) -> isize {
579
589
unsafe { atomic_xor ( self . v . get ( ) , val, order) }
580
590
}
@@ -592,6 +602,7 @@ impl AtomicUsize {
592
602
/// let atomic_forty_two = AtomicUsize::new(42);
593
603
/// ```
594
604
#[ inline]
605
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
595
606
pub fn new ( v : usize ) -> AtomicUsize {
596
607
AtomicUsize { v : UnsafeCell :: new ( v) }
597
608
}
@@ -614,6 +625,7 @@ impl AtomicUsize {
614
625
/// let value = some_usize.load(Ordering::Relaxed);
615
626
/// ```
616
627
#[ inline]
628
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
617
629
pub fn load ( & self , order : Ordering ) -> usize {
618
630
unsafe { atomic_load ( self . v . get ( ) , order) }
619
631
}
@@ -636,6 +648,7 @@ impl AtomicUsize {
636
648
///
637
649
/// Panics if `order` is `Acquire` or `AcqRel`.
638
650
#[ inline]
651
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
639
652
pub fn store ( & self , val : usize , order : Ordering ) {
640
653
unsafe { atomic_store ( self . v . get ( ) , val, order) ; }
641
654
}
@@ -654,6 +667,7 @@ impl AtomicUsize {
654
667
/// let value = some_usize.swap(10, Ordering::Relaxed);
655
668
/// ```
656
669
#[ inline]
670
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
657
671
pub fn swap ( & self , val : usize , order : Ordering ) -> usize {
658
672
unsafe { atomic_swap ( self . v . get ( ) , val, order) }
659
673
}
@@ -675,6 +689,7 @@ impl AtomicUsize {
675
689
/// let value = some_usize.compare_and_swap(5, 10, Ordering::Relaxed);
676
690
/// ```
677
691
#[ inline]
692
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
678
693
pub fn compare_and_swap ( & self , old : usize , new : usize , order : Ordering ) -> usize {
679
694
unsafe { atomic_compare_and_swap ( self . v . get ( ) , old, new, order) }
680
695
}
@@ -691,6 +706,7 @@ impl AtomicUsize {
691
706
/// assert_eq!(10, foo.load(Ordering::SeqCst));
692
707
/// ```
693
708
#[ inline]
709
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
694
710
pub fn fetch_add ( & self , val : usize , order : Ordering ) -> usize {
695
711
unsafe { atomic_add ( self . v . get ( ) , val, order) }
696
712
}
@@ -707,6 +723,7 @@ impl AtomicUsize {
707
723
/// assert_eq!(0, foo.load(Ordering::SeqCst));
708
724
/// ```
709
725
#[ inline]
726
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
710
727
pub fn fetch_sub ( & self , val : usize , order : Ordering ) -> usize {
711
728
unsafe { atomic_sub ( self . v . get ( ) , val, order) }
712
729
}
@@ -722,6 +739,7 @@ impl AtomicUsize {
722
739
/// assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst));
723
740
/// assert_eq!(0b100001, foo.load(Ordering::SeqCst));
724
741
#[ inline]
742
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
725
743
pub fn fetch_and ( & self , val : usize , order : Ordering ) -> usize {
726
744
unsafe { atomic_and ( self . v . get ( ) , val, order) }
727
745
}
@@ -737,6 +755,7 @@ impl AtomicUsize {
737
755
/// assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst));
738
756
/// assert_eq!(0b111111, foo.load(Ordering::SeqCst));
739
757
#[ inline]
758
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
740
759
pub fn fetch_or ( & self , val : usize , order : Ordering ) -> usize {
741
760
unsafe { atomic_or ( self . v . get ( ) , val, order) }
742
761
}
@@ -752,6 +771,7 @@ impl AtomicUsize {
752
771
/// assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst));
753
772
/// assert_eq!(0b011110, foo.load(Ordering::SeqCst));
754
773
#[ inline]
774
+ #[ stable( feature = "rust1" , since = "1.0.0" ) ]
755
775
pub fn fetch_xor ( & self , val : usize , order : Ordering ) -> usize {
756
776
unsafe { atomic_xor ( self . v . get ( ) , val, order) }
757
777
}
0 commit comments