1 #[cfg(feature = "with-serde")] 2 use serde; 3 4 use std::borrow::Borrow; 5 use std::cmp::Ordering; 6 use std::default::Default; 7 use std::fmt; 8 use std::hash::Hash; 9 use std::hash::Hasher; 10 use std::iter::FromIterator; 11 use std::iter::IntoIterator; 12 use std::ops::Deref; 13 use std::ops::DerefMut; 14 use std::ops::Index; 15 use std::ops::IndexMut; 16 use std::slice; 17 use std::vec; 18 19 use clear::Clear; 20 21 /// Wrapper around vector to avoid deallocations on clear. 22 pub struct RepeatedField<T> { 23 vec: Vec<T>, 24 len: usize, 25 } 26 27 impl<T> RepeatedField<T> { 28 /// Return number of elements in this container. 29 #[inline] len(&self) -> usize30 pub fn len(&self) -> usize { 31 self.len 32 } 33 34 /// Clear. 35 #[inline] clear(&mut self)36 pub fn clear(&mut self) { 37 self.len = 0; 38 } 39 } 40 41 impl<T> Clear for RepeatedField<T> { 42 #[inline] clear(&mut self)43 fn clear(&mut self) { 44 self.len = 0; 45 } 46 } 47 48 impl<T> Default for RepeatedField<T> { 49 #[inline] default() -> RepeatedField<T>50 fn default() -> RepeatedField<T> { 51 RepeatedField { 52 vec: Vec::new(), 53 len: 0, 54 } 55 } 56 } 57 58 impl<T> RepeatedField<T> { 59 /// Create new empty container. 60 #[inline] new() -> RepeatedField<T>61 pub fn new() -> RepeatedField<T> { 62 Default::default() 63 } 64 65 /// Create a contained with data from given vec. 66 #[inline] from_vec(vec: Vec<T>) -> RepeatedField<T>67 pub fn from_vec(vec: Vec<T>) -> RepeatedField<T> { 68 let len = vec.len(); 69 RepeatedField { vec: vec, len: len } 70 } 71 72 /// Convert data into vec. 73 #[inline] into_vec(self) -> Vec<T>74 pub fn into_vec(self) -> Vec<T> { 75 let mut vec = self.vec; 76 vec.truncate(self.len); 77 vec 78 } 79 80 /// Return current capacity. 81 #[inline] capacity(&self) -> usize82 pub fn capacity(&self) -> usize { 83 self.vec.capacity() 84 } 85 86 /// View data as slice. 87 #[inline] as_slice<'a>(&'a self) -> &'a [T]88 pub fn as_slice<'a>(&'a self) -> &'a [T] { 89 &self.vec[..self.len] 90 } 91 92 /// View data as mutable slice. 93 #[inline] as_mut_slice<'a>(&'a mut self) -> &'a mut [T]94 pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] { 95 &mut self.vec[..self.len] 96 } 97 98 /// Get subslice of this container. 99 #[inline] slice(&self, start: usize, end: usize) -> &[T]100 pub fn slice(&self, start: usize, end: usize) -> &[T] { 101 &self.as_ref()[start..end] 102 } 103 104 /// Get mutable subslice of this container. 105 #[inline] slice_mut(&mut self, start: usize, end: usize) -> &mut [T]106 pub fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] { 107 &mut self.as_mut_slice()[start..end] 108 } 109 110 /// Get slice from given index. 111 #[inline] slice_from(&self, start: usize) -> &[T]112 pub fn slice_from(&self, start: usize) -> &[T] { 113 &self.as_ref()[start..] 114 } 115 116 /// Get mutable slice from given index. 117 #[inline] slice_from_mut(&mut self, start: usize) -> &mut [T]118 pub fn slice_from_mut(&mut self, start: usize) -> &mut [T] { 119 &mut self.as_mut_slice()[start..] 120 } 121 122 /// Get slice to given index. 123 #[inline] slice_to(&self, end: usize) -> &[T]124 pub fn slice_to(&self, end: usize) -> &[T] { 125 &self.as_ref()[..end] 126 } 127 128 /// Get mutable slice to given index. 129 #[inline] slice_to_mut(&mut self, end: usize) -> &mut [T]130 pub fn slice_to_mut(&mut self, end: usize) -> &mut [T] { 131 &mut self.as_mut_slice()[..end] 132 } 133 134 /// View this container as two slices split at given index. 135 #[inline] split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T])136 pub fn split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T]) { 137 self.as_ref().split_at(mid) 138 } 139 140 /// View this container as two mutable slices split at given index. 141 #[inline] split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T])142 pub fn split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T]) { 143 self.as_mut_slice().split_at_mut(mid) 144 } 145 146 /// View all but first elements of this container. 147 #[inline] tail(&self) -> &[T]148 pub fn tail(&self) -> &[T] { 149 &self.as_ref()[1..] 150 } 151 152 /// Last element of this container. 153 #[inline] last(&self) -> Option<&T>154 pub fn last(&self) -> Option<&T> { 155 self.as_ref().last() 156 } 157 158 /// Mutable last element of this container. 159 #[inline] last_mut<'a>(&'a mut self) -> Option<&'a mut T>160 pub fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> { 161 self.as_mut_slice().last_mut() 162 } 163 164 /// View all but last elements of this container. 165 #[inline] init<'a>(&'a self) -> &'a [T]166 pub fn init<'a>(&'a self) -> &'a [T] { 167 let s = self.as_ref(); 168 &s[0..s.len() - 1] 169 } 170 171 /// Push an element to the end. 172 #[inline] push(&mut self, value: T)173 pub fn push(&mut self, value: T) { 174 if self.len == self.vec.len() { 175 self.vec.push(value); 176 } else { 177 self.vec[self.len] = value; 178 } 179 self.len += 1; 180 } 181 182 /// Pop last element. 183 #[inline] pop(&mut self) -> Option<T>184 pub fn pop(&mut self) -> Option<T> { 185 if self.len == 0 { 186 None 187 } else { 188 self.vec.truncate(self.len); 189 self.len -= 1; 190 self.vec.pop() 191 } 192 } 193 194 /// Insert an element at specified position. 195 #[inline] insert(&mut self, index: usize, value: T)196 pub fn insert(&mut self, index: usize, value: T) { 197 assert!(index <= self.len); 198 self.vec.insert(index, value); 199 self.len += 1; 200 } 201 202 /// Remove an element from specified position. 203 #[inline] remove(&mut self, index: usize) -> T204 pub fn remove(&mut self, index: usize) -> T { 205 assert!(index < self.len); 206 self.len -= 1; 207 self.vec.remove(index) 208 } 209 210 /// Truncate at specified length. 211 #[inline] truncate(&mut self, len: usize)212 pub fn truncate(&mut self, len: usize) { 213 if self.len > len { 214 self.len = len; 215 } 216 } 217 218 /// Reverse in place. 219 #[inline] reverse(&mut self)220 pub fn reverse(&mut self) { 221 self.as_mut_slice().reverse() 222 } 223 224 /// Into owned iterator. 225 #[inline] into_iter(mut self) -> vec::IntoIter<T>226 pub fn into_iter(mut self) -> vec::IntoIter<T> { 227 self.vec.truncate(self.len); 228 self.vec.into_iter() 229 } 230 231 /// Immutable data iterator. 232 #[inline] iter<'a>(&'a self) -> slice::Iter<'a, T>233 pub fn iter<'a>(&'a self) -> slice::Iter<'a, T> { 234 self.as_ref().iter() 235 } 236 237 /// Mutable data iterator. 238 #[inline] iter_mut<'a>(&'a mut self) -> slice::IterMut<'a, T>239 pub fn iter_mut<'a>(&'a mut self) -> slice::IterMut<'a, T> { 240 self.as_mut_slice().iter_mut() 241 } 242 243 /// Sort elements with given comparator. 244 #[inline] sort_by<F>(&mut self, compare: F) where F: Fn(&T, &T) -> Ordering,245 pub fn sort_by<F>(&mut self, compare: F) 246 where 247 F: Fn(&T, &T) -> Ordering, 248 { 249 self.as_mut_slice().sort_by(compare) 250 } 251 252 /// Get data as raw pointer. 253 #[inline] as_ptr(&self) -> *const T254 pub fn as_ptr(&self) -> *const T { 255 self.vec.as_ptr() 256 } 257 258 /// Get data a mutable raw pointer. 259 #[inline] as_mut_ptr(&mut self) -> *mut T260 pub fn as_mut_ptr(&mut self) -> *mut T { 261 self.vec.as_mut_ptr() 262 } 263 } 264 265 impl<T: Default + Clear> RepeatedField<T> { 266 /// Push default value. 267 /// This operation could be faster than `rf.push(Default::default())`, 268 /// because it may reuse previously allocated and cleared element. push_default<'a>(&'a mut self) -> &'a mut T269 pub fn push_default<'a>(&'a mut self) -> &'a mut T { 270 if self.len == self.vec.len() { 271 self.vec.push(Default::default()); 272 } else { 273 self.vec[self.len].clear(); 274 } 275 self.len += 1; 276 self.last_mut().unwrap() 277 } 278 } 279 280 impl<T> From<Vec<T>> for RepeatedField<T> { 281 #[inline] from(values: Vec<T>) -> RepeatedField<T>282 fn from(values: Vec<T>) -> RepeatedField<T> { 283 RepeatedField::from_vec(values) 284 } 285 } 286 287 impl<'a, T: Clone> From<&'a [T]> for RepeatedField<T> { 288 #[inline] from(values: &'a [T]) -> RepeatedField<T>289 fn from(values: &'a [T]) -> RepeatedField<T> { 290 RepeatedField::from_slice(values) 291 } 292 } 293 294 impl<T> Into<Vec<T>> for RepeatedField<T> { 295 #[inline] into(self) -> Vec<T>296 fn into(self) -> Vec<T> { 297 self.into_vec() 298 } 299 } 300 301 impl<T: Clone> RepeatedField<T> { 302 /// Copy slice data to `RepeatedField` 303 #[inline] from_slice(values: &[T]) -> RepeatedField<T>304 pub fn from_slice(values: &[T]) -> RepeatedField<T> { 305 RepeatedField::from_vec(values.to_vec()) 306 } 307 308 /// Copy slice data to `RepeatedField` 309 #[inline] from_ref<X: AsRef<[T]>>(values: X) -> RepeatedField<T>310 pub fn from_ref<X: AsRef<[T]>>(values: X) -> RepeatedField<T> { 311 RepeatedField::from_slice(values.as_ref()) 312 } 313 314 /// Copy this data into new vec. 315 #[inline] to_vec(&self) -> Vec<T>316 pub fn to_vec(&self) -> Vec<T> { 317 self.as_ref().to_vec() 318 } 319 } 320 321 impl<T: Clone> Clone for RepeatedField<T> { 322 #[inline] clone(&self) -> RepeatedField<T>323 fn clone(&self) -> RepeatedField<T> { 324 RepeatedField { 325 vec: self.to_vec(), 326 len: self.len(), 327 } 328 } 329 } 330 331 impl<T> FromIterator<T> for RepeatedField<T> { 332 #[inline] from_iter<I: IntoIterator<Item = T>>(iter: I) -> RepeatedField<T>333 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> RepeatedField<T> { 334 RepeatedField::from_vec(FromIterator::from_iter(iter)) 335 } 336 } 337 338 impl<'a, T> IntoIterator for &'a RepeatedField<T> { 339 type Item = &'a T; 340 type IntoIter = slice::Iter<'a, T>; 341 into_iter(self) -> slice::Iter<'a, T>342 fn into_iter(self) -> slice::Iter<'a, T> { 343 self.iter() 344 } 345 } 346 347 impl<T: PartialEq> PartialEq for RepeatedField<T> { 348 #[inline] eq(&self, other: &RepeatedField<T>) -> bool349 fn eq(&self, other: &RepeatedField<T>) -> bool { 350 self.as_ref() == other.as_ref() 351 } 352 } 353 354 impl<T: Eq> Eq for RepeatedField<T> {} 355 356 impl<T: PartialEq> RepeatedField<T> { 357 /// True iff this container contains given element. 358 #[inline] contains(&self, value: &T) -> bool359 pub fn contains(&self, value: &T) -> bool { 360 self.as_ref().contains(value) 361 } 362 } 363 364 impl<T: Hash> Hash for RepeatedField<T> { hash<H: Hasher>(&self, state: &mut H)365 fn hash<H: Hasher>(&self, state: &mut H) { 366 self.as_ref().hash(state); 367 } 368 } 369 370 impl<T> AsRef<[T]> for RepeatedField<T> { 371 #[inline] as_ref<'a>(&'a self) -> &'a [T]372 fn as_ref<'a>(&'a self) -> &'a [T] { 373 &self.vec[..self.len] 374 } 375 } 376 377 impl<T> Borrow<[T]> for RepeatedField<T> { 378 #[inline] borrow(&self) -> &[T]379 fn borrow(&self) -> &[T] { 380 &self.vec[..self.len] 381 } 382 } 383 384 impl<T> Deref for RepeatedField<T> { 385 type Target = [T]; 386 #[inline] deref(&self) -> &[T]387 fn deref(&self) -> &[T] { 388 &self.vec[..self.len] 389 } 390 } 391 392 impl<T> DerefMut for RepeatedField<T> { 393 #[inline] deref_mut(&mut self) -> &mut [T]394 fn deref_mut(&mut self) -> &mut [T] { 395 &mut self.vec[..self.len] 396 } 397 } 398 399 impl<T> Index<usize> for RepeatedField<T> { 400 type Output = T; 401 402 #[inline] index<'a>(&'a self, index: usize) -> &'a T403 fn index<'a>(&'a self, index: usize) -> &'a T { 404 &self.as_ref()[index] 405 } 406 } 407 408 impl<T> IndexMut<usize> for RepeatedField<T> { 409 #[inline] index_mut<'a>(&'a mut self, index: usize) -> &'a mut T410 fn index_mut<'a>(&'a mut self, index: usize) -> &'a mut T { 411 &mut self.as_mut_slice()[index] 412 } 413 } 414 415 impl<T: fmt::Debug> fmt::Debug for RepeatedField<T> { 416 #[inline] fmt(&self, f: &mut fmt::Formatter) -> fmt::Result417 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 418 self.as_ref().fmt(f) 419 } 420 } 421 422 #[cfg(feature = "with-serde")] 423 impl<T: serde::Serialize> serde::Serialize for RepeatedField<T> { serialize<S>( &self, serializer: S, ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error> where S: serde::Serializer,424 fn serialize<S>( 425 &self, 426 serializer: S, 427 ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error> 428 where 429 S: serde::Serializer, 430 { 431 self.as_ref().serialize(serializer) 432 } 433 } 434 435 #[cfg(feature = "with-serde")] 436 impl<'de, T: serde::Deserialize<'de> + Default> serde::Deserialize<'de> for RepeatedField<T> { deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error> where D: serde::Deserializer<'de>,437 fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error> 438 where 439 D: serde::Deserializer<'de>, 440 { 441 Vec::deserialize(deserializer).map(RepeatedField::from) 442 } 443 } 444 445 #[cfg(test)] 446 mod test { 447 use super::RepeatedField; 448 449 #[test] as_mut_slice()450 fn as_mut_slice() { 451 let mut v = RepeatedField::new(); 452 v.push(10); 453 v.push(20); 454 v.clear(); 455 assert_eq!(v.as_mut_slice(), &mut []); 456 v.push(30); 457 assert_eq!(v.as_mut_slice(), &mut [30]); 458 } 459 460 #[test] push_default()461 fn push_default() { 462 let mut v = RepeatedField::new(); 463 v.push("aa".to_string()); 464 v.push("bb".to_string()); 465 v.clear(); 466 assert_eq!("".to_string(), *v.push_default()); 467 } 468 } 469