@@ -555,10 +555,10 @@ impl <K, V> Node<K, V> {
555
555
let node = mem:: replace ( left_and_out, unsafe { Node :: new_internal ( capacity_from_b ( b) ) } ) ;
556
556
left_and_out. _len = 1 ;
557
557
unsafe {
558
- ptr:: write ( left_and_out. keys_mut ( ) . unsafe_mut ( 0 ) , key) ;
559
- ptr:: write ( left_and_out. vals_mut ( ) . unsafe_mut ( 0 ) , value) ;
560
- ptr:: write ( left_and_out. edges_mut ( ) . unsafe_mut ( 0 ) , node) ;
561
- ptr:: write ( left_and_out. edges_mut ( ) . unsafe_mut ( 1 ) , right) ;
558
+ ptr:: write ( left_and_out. keys_mut ( ) . get_unchecked_mut ( 0 ) , key) ;
559
+ ptr:: write ( left_and_out. vals_mut ( ) . get_unchecked_mut ( 0 ) , value) ;
560
+ ptr:: write ( left_and_out. edges_mut ( ) . get_unchecked_mut ( 0 ) , node) ;
561
+ ptr:: write ( left_and_out. edges_mut ( ) . get_unchecked_mut ( 1 ) , right) ;
562
562
}
563
563
}
564
564
@@ -637,7 +637,7 @@ impl<'a, K: 'a, V: 'a> Handle<&'a Node<K, V>, handle::Edge, handle::Internal> {
637
637
/// making it more suitable for moving down a chain of nodes.
638
638
pub fn into_edge ( self ) -> & ' a Node < K , V > {
639
639
unsafe {
640
- self . node . edges ( ) . unsafe_get ( self . index )
640
+ self . node . edges ( ) . get_unchecked ( self . index )
641
641
}
642
642
}
643
643
}
@@ -648,7 +648,7 @@ impl<'a, K: 'a, V: 'a> Handle<&'a mut Node<K, V>, handle::Edge, handle::Internal
648
648
/// `edge_mut`, making it more suitable for moving down a chain of nodes.
649
649
pub fn into_edge_mut ( self ) -> & ' a mut Node < K , V > {
650
650
unsafe {
651
- self . node . edges_mut ( ) . unsafe_mut ( self . index )
651
+ self . node . edges_mut ( ) . get_unchecked_mut ( self . index )
652
652
}
653
653
}
654
654
}
@@ -722,7 +722,7 @@ impl<K, V, NodeRef: DerefMut<Node<K, V>>> Handle<NodeRef, handle::Edge, handle::
722
722
/// confused with `node`, which references the parent node of what is returned here.
723
723
pub fn edge_mut ( & mut self ) -> & mut Node < K , V > {
724
724
unsafe {
725
- self . node . edges_mut ( ) . unsafe_mut ( self . index )
725
+ self . node . edges_mut ( ) . get_unchecked_mut ( self . index )
726
726
}
727
727
}
728
728
@@ -830,8 +830,8 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle<&'a Node<K, V>, handle::KV, NodeType> {
830
830
let ( keys, vals) = self . node . as_slices ( ) ;
831
831
unsafe {
832
832
(
833
- keys. unsafe_get ( self . index ) ,
834
- vals. unsafe_get ( self . index )
833
+ keys. get_unchecked ( self . index ) ,
834
+ vals. get_unchecked ( self . index )
835
835
)
836
836
}
837
837
}
@@ -845,8 +845,8 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle<&'a mut Node<K, V>, handle::KV, NodeType
845
845
let ( keys, vals) = self . node . as_slices_mut ( ) ;
846
846
unsafe {
847
847
(
848
- keys. unsafe_mut ( self . index ) ,
849
- vals. unsafe_mut ( self . index )
848
+ keys. get_unchecked_mut ( self . index ) ,
849
+ vals. get_unchecked_mut ( self . index )
850
850
)
851
851
}
852
852
}
@@ -870,14 +870,14 @@ impl<'a, K: 'a, V: 'a, NodeRef: Deref<Node<K, V>> + 'a, NodeType> Handle<NodeRef
870
870
// /// reference with a lifetime as large as `into_kv_mut`, but it also does not consume the
871
871
// /// handle.
872
872
// pub fn key(&'a self) -> &'a K {
873
- // unsafe { self.node.keys().unsafe_get (self.index) }
873
+ // unsafe { self.node.keys().get_unchecked (self.index) }
874
874
// }
875
875
//
876
876
// /// Returns a reference to the value pointed-to by this handle. This doesn't return a
877
877
// /// reference with a lifetime as large as `into_kv_mut`, but it also does not consume the
878
878
// /// handle.
879
879
// pub fn val(&'a self) -> &'a V {
880
- // unsafe { self.node.vals().unsafe_get (self.index) }
880
+ // unsafe { self.node.vals().get_unchecked (self.index) }
881
881
// }
882
882
}
883
883
@@ -887,14 +887,14 @@ impl<'a, K: 'a, V: 'a, NodeRef: DerefMut<Node<K, V>> + 'a, NodeType> Handle<Node
887
887
/// reference with a lifetime as large as `into_kv_mut`, but it also does not consume the
888
888
/// handle.
889
889
pub fn key_mut ( & ' a mut self ) -> & ' a mut K {
890
- unsafe { self . node . keys_mut ( ) . unsafe_mut ( self . index ) }
890
+ unsafe { self . node . keys_mut ( ) . get_unchecked_mut ( self . index ) }
891
891
}
892
892
893
893
/// Returns a mutable reference to the value pointed-to by this handle. This doesn't return a
894
894
/// reference with a lifetime as large as `into_kv_mut`, but it also does not consume the
895
895
/// handle.
896
896
pub fn val_mut ( & ' a mut self ) -> & ' a mut V {
897
- unsafe { self . node . vals_mut ( ) . unsafe_mut ( self . index ) }
897
+ unsafe { self . node . vals_mut ( ) . get_unchecked_mut ( self . index ) }
898
898
}
899
899
}
900
900
@@ -1078,7 +1078,7 @@ impl<K, V> Node<K, V> {
1078
1078
debug_assert ! ( !self . is_leaf( ) ) ;
1079
1079
1080
1080
unsafe {
1081
- let ret = ptr:: read ( self . edges ( ) . unsafe_get ( 0 ) ) ;
1081
+ let ret = ptr:: read ( self . edges ( ) . get_unchecked ( 0 ) ) ;
1082
1082
self . destroy ( ) ;
1083
1083
ptr:: write ( self , ret) ;
1084
1084
}
@@ -1092,8 +1092,8 @@ impl<K, V> Node<K, V> {
1092
1092
unsafe fn push_kv ( & mut self , key : K , val : V ) {
1093
1093
let len = self . len ( ) ;
1094
1094
1095
- ptr:: write ( self . keys_mut ( ) . unsafe_mut ( len) , key) ;
1096
- ptr:: write ( self . vals_mut ( ) . unsafe_mut ( len) , val) ;
1095
+ ptr:: write ( self . keys_mut ( ) . get_unchecked_mut ( len) , key) ;
1096
+ ptr:: write ( self . vals_mut ( ) . get_unchecked_mut ( len) , val) ;
1097
1097
1098
1098
self . _len += 1 ;
1099
1099
}
@@ -1103,7 +1103,7 @@ impl<K, V> Node<K, V> {
1103
1103
unsafe fn push_edge ( & mut self , edge : Node < K , V > ) {
1104
1104
let len = self . len ( ) ;
1105
1105
1106
- ptr:: write ( self . edges_mut ( ) . unsafe_mut ( len) , edge) ;
1106
+ ptr:: write ( self . edges_mut ( ) . get_unchecked_mut ( len) , edge) ;
1107
1107
}
1108
1108
1109
1109
// This must be followed by insert_edge on an internal node.
@@ -1120,12 +1120,12 @@ impl<K, V> Node<K, V> {
1120
1120
self . len ( ) - index
1121
1121
) ;
1122
1122
1123
- ptr:: write ( self . keys_mut ( ) . unsafe_mut ( index) , key) ;
1124
- ptr:: write ( self . vals_mut ( ) . unsafe_mut ( index) , val) ;
1123
+ ptr:: write ( self . keys_mut ( ) . get_unchecked_mut ( index) , key) ;
1124
+ ptr:: write ( self . vals_mut ( ) . get_unchecked_mut ( index) , val) ;
1125
1125
1126
1126
self . _len += 1 ;
1127
1127
1128
- self . vals_mut ( ) . unsafe_mut ( index)
1128
+ self . vals_mut ( ) . get_unchecked_mut ( index)
1129
1129
}
1130
1130
1131
1131
// This can only be called immediately after a call to insert_kv.
@@ -1136,14 +1136,14 @@ impl<K, V> Node<K, V> {
1136
1136
self . edges ( ) . as_ptr ( ) . offset ( index as int ) ,
1137
1137
self . len ( ) - index
1138
1138
) ;
1139
- ptr:: write ( self . edges_mut ( ) . unsafe_mut ( index) , edge) ;
1139
+ ptr:: write ( self . edges_mut ( ) . get_unchecked_mut ( index) , edge) ;
1140
1140
}
1141
1141
1142
1142
// This must be followed by pop_edge on an internal node.
1143
1143
#[ inline]
1144
1144
unsafe fn pop_kv ( & mut self ) -> ( K , V ) {
1145
- let key = ptr:: read ( self . keys ( ) . unsafe_get ( self . len ( ) - 1 ) ) ;
1146
- let val = ptr:: read ( self . vals ( ) . unsafe_get ( self . len ( ) - 1 ) ) ;
1145
+ let key = ptr:: read ( self . keys ( ) . get_unchecked ( self . len ( ) - 1 ) ) ;
1146
+ let val = ptr:: read ( self . vals ( ) . get_unchecked ( self . len ( ) - 1 ) ) ;
1147
1147
1148
1148
self . _len -= 1 ;
1149
1149
@@ -1153,16 +1153,16 @@ impl<K, V> Node<K, V> {
1153
1153
// This can only be called immediately after a call to pop_kv.
1154
1154
#[ inline]
1155
1155
unsafe fn pop_edge ( & mut self ) -> Node < K , V > {
1156
- let edge = ptr:: read ( self . edges ( ) . unsafe_get ( self . len ( ) + 1 ) ) ;
1156
+ let edge = ptr:: read ( self . edges ( ) . get_unchecked ( self . len ( ) + 1 ) ) ;
1157
1157
1158
1158
edge
1159
1159
}
1160
1160
1161
1161
// This must be followed by remove_edge on an internal node.
1162
1162
#[ inline]
1163
1163
unsafe fn remove_kv ( & mut self , index : uint ) -> ( K , V ) {
1164
- let key = ptr:: read ( self . keys ( ) . unsafe_get ( index) ) ;
1165
- let val = ptr:: read ( self . vals ( ) . unsafe_get ( index) ) ;
1164
+ let key = ptr:: read ( self . keys ( ) . get_unchecked ( index) ) ;
1165
+ let val = ptr:: read ( self . vals ( ) . get_unchecked ( index) ) ;
1166
1166
1167
1167
ptr:: copy_memory (
1168
1168
self . keys_mut ( ) . as_mut_ptr ( ) . offset ( index as int ) ,
@@ -1183,7 +1183,7 @@ impl<K, V> Node<K, V> {
1183
1183
// This can only be called immediately after a call to remove_kv.
1184
1184
#[ inline]
1185
1185
unsafe fn remove_edge ( & mut self , index : uint ) -> Node < K , V > {
1186
- let edge = ptr:: read ( self . edges ( ) . unsafe_get ( index) ) ;
1186
+ let edge = ptr:: read ( self . edges ( ) . get_unchecked ( index) ) ;
1187
1187
1188
1188
ptr:: copy_memory (
1189
1189
self . edges_mut ( ) . as_mut_ptr ( ) . offset ( index as int ) ,
@@ -1230,8 +1230,8 @@ impl<K, V> Node<K, V> {
1230
1230
) ;
1231
1231
}
1232
1232
1233
- let key = ptr:: read ( self . keys ( ) . unsafe_get ( right_offset - 1 ) ) ;
1234
- let val = ptr:: read ( self . vals ( ) . unsafe_get ( right_offset - 1 ) ) ;
1233
+ let key = ptr:: read ( self . keys ( ) . get_unchecked ( right_offset - 1 ) ) ;
1234
+ let val = ptr:: read ( self . vals ( ) . get_unchecked ( right_offset - 1 ) ) ;
1235
1235
1236
1236
self . _len = right_offset - 1 ;
1237
1237
@@ -1250,8 +1250,8 @@ impl<K, V> Node<K, V> {
1250
1250
let old_len = self . len ( ) ;
1251
1251
self . _len += right. len ( ) + 1 ;
1252
1252
1253
- ptr:: write ( self . keys_mut ( ) . unsafe_mut ( old_len) , key) ;
1254
- ptr:: write ( self . vals_mut ( ) . unsafe_mut ( old_len) , val) ;
1253
+ ptr:: write ( self . keys_mut ( ) . get_unchecked_mut ( old_len) , key) ;
1254
+ ptr:: write ( self . vals_mut ( ) . get_unchecked_mut ( old_len) , val) ;
1255
1255
1256
1256
ptr:: copy_nonoverlapping_memory (
1257
1257
self . keys_mut ( ) . as_mut_ptr ( ) . offset ( old_len as int + 1 ) ,
0 commit comments