diff options
Diffstat (limited to 'src/repeated.rs')
| -rw-r--r-- | src/repeated.rs | 563 |
1 files changed, 0 insertions, 563 deletions
diff --git a/src/repeated.rs b/src/repeated.rs deleted file mode 100644 index 0b749d9..0000000 --- a/src/repeated.rs +++ /dev/null @@ -1,563 +0,0 @@ -use std::borrow::Borrow; -use std::cmp::Ordering; -use std::default::Default; -use std::fmt; -use std::hash::Hash; -use std::hash::Hasher; -use std::iter::FromIterator; -use std::iter::IntoIterator; -use std::ops::Deref; -use std::ops::DerefMut; -use std::ops::Index; -use std::ops::IndexMut; -use std::slice; -use std::vec; - -#[cfg(feature = "with-serde")] -use serde; - -use crate::clear::Clear; - -/// Wrapper around vector to avoid deallocations on clear. -pub struct RepeatedField<T> { - vec: Vec<T>, - len: usize, -} - -impl<T> RepeatedField<T> { - /// Return number of elements in this container. - #[inline] - pub fn len(&self) -> usize { - self.len - } - - /// Clear. - #[inline] - pub fn clear(&mut self) { - self.len = 0; - } -} - -impl<T> Clear for RepeatedField<T> { - #[inline] - fn clear(&mut self) { - self.len = 0; - } -} - -impl<T> Default for RepeatedField<T> { - #[inline] - fn default() -> RepeatedField<T> { - RepeatedField { - vec: Vec::new(), - len: 0, - } - } -} - -impl<T> RepeatedField<T> { - /// Create new empty container. - #[inline] - pub fn new() -> RepeatedField<T> { - Default::default() - } - - /// Create a contained with data from given vec. - #[inline] - pub fn from_vec(vec: Vec<T>) -> RepeatedField<T> { - let len = vec.len(); - RepeatedField { vec: vec, len: len } - } - - /// Convert data into vec. - #[inline] - pub fn into_vec(self) -> Vec<T> { - let mut vec = self.vec; - vec.truncate(self.len); - vec - } - - /// Return current capacity. - #[inline] - pub fn capacity(&self) -> usize { - self.vec.capacity() - } - - /// View data as slice. - #[inline] - pub fn as_slice<'a>(&'a self) -> &'a [T] { - &self.vec[..self.len] - } - - /// View data as mutable slice. - #[inline] - pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] { - &mut self.vec[..self.len] - } - - /// Get subslice of this container. - #[inline] - pub fn slice(&self, start: usize, end: usize) -> &[T] { - &self.as_ref()[start..end] - } - - /// Get mutable subslice of this container. - #[inline] - pub fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] { - &mut self.as_mut_slice()[start..end] - } - - /// Get slice from given index. - #[inline] - pub fn slice_from(&self, start: usize) -> &[T] { - &self.as_ref()[start..] - } - - /// Get mutable slice from given index. - #[inline] - pub fn slice_from_mut(&mut self, start: usize) -> &mut [T] { - &mut self.as_mut_slice()[start..] - } - - /// Get slice to given index. - #[inline] - pub fn slice_to(&self, end: usize) -> &[T] { - &self.as_ref()[..end] - } - - /// Get mutable slice to given index. - #[inline] - pub fn slice_to_mut(&mut self, end: usize) -> &mut [T] { - &mut self.as_mut_slice()[..end] - } - - /// View this container as two slices split at given index. - #[inline] - pub fn split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T]) { - self.as_ref().split_at(mid) - } - - /// View this container as two mutable slices split at given index. - #[inline] - pub fn split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T]) { - self.as_mut_slice().split_at_mut(mid) - } - - /// View all but first elements of this container. - #[inline] - pub fn tail(&self) -> &[T] { - &self.as_ref()[1..] - } - - /// Last element of this container. - #[inline] - pub fn last(&self) -> Option<&T> { - self.as_ref().last() - } - - /// Mutable last element of this container. - #[inline] - pub fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> { - self.as_mut_slice().last_mut() - } - - /// View all but last elements of this container. - #[inline] - pub fn init<'a>(&'a self) -> &'a [T] { - let s = self.as_ref(); - &s[0..s.len() - 1] - } - - /// Push an element to the end. - #[inline] - pub fn push(&mut self, value: T) { - if self.len == self.vec.len() { - self.vec.push(value); - } else { - self.vec[self.len] = value; - } - self.len += 1; - } - - /// Pop last element. - #[inline] - pub fn pop(&mut self) -> Option<T> { - if self.len == 0 { - None - } else { - self.vec.truncate(self.len); - self.len -= 1; - self.vec.pop() - } - } - - /// Insert an element at specified position. - #[inline] - pub fn insert(&mut self, index: usize, value: T) { - assert!(index <= self.len); - self.vec.insert(index, value); - self.len += 1; - } - - /// Remove an element from specified position. - #[inline] - pub fn remove(&mut self, index: usize) -> T { - assert!(index < self.len); - self.len -= 1; - self.vec.remove(index) - } - - /// Retains only the elements specified by the predicate. - /// - /// In other words, remove all elements `e` such that `f(&e)` returns `false`. - /// This method operates in place, visiting each element exactly once in the - /// original order, and preserves the order of the retained elements. - /// - /// # Examples - /// - /// ``` - /// # use protobuf::RepeatedField; - /// - /// let mut vec = RepeatedField::from(vec![1, 2, 3, 4]); - /// vec.retain(|&x| x % 2 == 0); - /// assert_eq!(vec, RepeatedField::from(vec![2, 4])); - /// ``` - pub fn retain<F>(&mut self, f: F) - where - F: FnMut(&T) -> bool, - { - // suboptimal - self.vec.truncate(self.len); - self.vec.retain(f); - self.len = self.vec.len(); - } - - /// Truncate at specified length. - #[inline] - pub fn truncate(&mut self, len: usize) { - if self.len > len { - self.len = len; - } - } - - /// Reverse in place. - #[inline] - pub fn reverse(&mut self) { - self.as_mut_slice().reverse() - } - - /// Into owned iterator. - #[inline] - pub fn into_iter(mut self) -> vec::IntoIter<T> { - self.vec.truncate(self.len); - self.vec.into_iter() - } - - /// Immutable data iterator. - #[inline] - pub fn iter<'a>(&'a self) -> slice::Iter<'a, T> { - self.as_ref().iter() - } - - /// Mutable data iterator. - #[inline] - pub fn iter_mut<'a>(&'a mut self) -> slice::IterMut<'a, T> { - self.as_mut_slice().iter_mut() - } - - /// Sort elements with given comparator. - #[inline] - pub fn sort_by<F>(&mut self, compare: F) - where - F: Fn(&T, &T) -> Ordering, - { - self.as_mut_slice().sort_by(compare) - } - - /// Get data as raw pointer. - #[inline] - pub fn as_ptr(&self) -> *const T { - self.vec.as_ptr() - } - - /// Get data a mutable raw pointer. - #[inline] - pub fn as_mut_ptr(&mut self) -> *mut T { - self.vec.as_mut_ptr() - } -} - -impl<T: Default + Clear> RepeatedField<T> { - /// Push default value. - /// This operation could be faster than `rf.push(Default::default())`, - /// because it may reuse previously allocated and cleared element. - pub fn push_default<'a>(&'a mut self) -> &'a mut T { - if self.len == self.vec.len() { - self.vec.push(Default::default()); - } else { - self.vec[self.len].clear(); - } - self.len += 1; - self.last_mut().unwrap() - } -} - -impl<T> From<Vec<T>> for RepeatedField<T> { - #[inline] - fn from(values: Vec<T>) -> RepeatedField<T> { - RepeatedField::from_vec(values) - } -} - -impl<'a, T: Clone> From<&'a [T]> for RepeatedField<T> { - #[inline] - fn from(values: &'a [T]) -> RepeatedField<T> { - RepeatedField::from_slice(values) - } -} - -impl<T> Into<Vec<T>> for RepeatedField<T> { - #[inline] - fn into(self) -> Vec<T> { - self.into_vec() - } -} - -impl<T: Clone> RepeatedField<T> { - /// Copy slice data to `RepeatedField` - #[inline] - pub fn from_slice(values: &[T]) -> RepeatedField<T> { - RepeatedField::from_vec(values.to_vec()) - } - - /// Copy slice data to `RepeatedField` - #[inline] - pub fn from_ref<X: AsRef<[T]>>(values: X) -> RepeatedField<T> { - RepeatedField::from_slice(values.as_ref()) - } - - /// Copy this data into new vec. - #[inline] - pub fn to_vec(&self) -> Vec<T> { - self.as_ref().to_vec() - } -} - -impl<T: Clone> Clone for RepeatedField<T> { - #[inline] - fn clone(&self) -> RepeatedField<T> { - RepeatedField { - vec: self.to_vec(), - len: self.len(), - } - } -} - -impl<T> FromIterator<T> for RepeatedField<T> { - #[inline] - fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> RepeatedField<T> { - RepeatedField::from_vec(FromIterator::from_iter(iter)) - } -} - -impl<'a, T> IntoIterator for &'a RepeatedField<T> { - type Item = &'a T; - type IntoIter = slice::Iter<'a, T>; - - fn into_iter(self) -> slice::Iter<'a, T> { - self.iter() - } -} - -impl<'a, T> IntoIterator for &'a mut RepeatedField<T> { - type Item = &'a mut T; - type IntoIter = slice::IterMut<'a, T>; - - fn into_iter(self) -> slice::IterMut<'a, T> { - self.iter_mut() - } -} - -impl<'a, T> IntoIterator for RepeatedField<T> { - type Item = T; - type IntoIter = vec::IntoIter<T>; - - fn into_iter(self) -> vec::IntoIter<T> { - self.into_iter() - } -} - -impl<T: PartialEq> PartialEq for RepeatedField<T> { - #[inline] - fn eq(&self, other: &RepeatedField<T>) -> bool { - self.as_ref() == other.as_ref() - } -} - -impl<T: Eq> Eq for RepeatedField<T> {} - -impl<T: PartialEq> PartialEq<[T]> for RepeatedField<T> { - fn eq(&self, other: &[T]) -> bool { - self.as_slice() == other - } -} - -impl<T: PartialEq> PartialEq<RepeatedField<T>> for [T] { - fn eq(&self, other: &RepeatedField<T>) -> bool { - self == other.as_slice() - } -} - -impl<T: PartialEq> RepeatedField<T> { - /// True iff this container contains given element. - #[inline] - pub fn contains(&self, value: &T) -> bool { - self.as_ref().contains(value) - } -} - -impl<T: Hash> Hash for RepeatedField<T> { - fn hash<H: Hasher>(&self, state: &mut H) { - self.as_ref().hash(state); - } -} - -impl<T> AsRef<[T]> for RepeatedField<T> { - #[inline] - fn as_ref<'a>(&'a self) -> &'a [T] { - &self.vec[..self.len] - } -} - -impl<T> Borrow<[T]> for RepeatedField<T> { - #[inline] - fn borrow(&self) -> &[T] { - &self.vec[..self.len] - } -} - -impl<T> Deref for RepeatedField<T> { - type Target = [T]; - #[inline] - fn deref(&self) -> &[T] { - &self.vec[..self.len] - } -} - -impl<T> DerefMut for RepeatedField<T> { - #[inline] - fn deref_mut(&mut self) -> &mut [T] { - &mut self.vec[..self.len] - } -} - -impl<T> Index<usize> for RepeatedField<T> { - type Output = T; - - #[inline] - fn index<'a>(&'a self, index: usize) -> &'a T { - &self.as_ref()[index] - } -} - -impl<T> IndexMut<usize> for RepeatedField<T> { - #[inline] - fn index_mut<'a>(&'a mut self, index: usize) -> &'a mut T { - &mut self.as_mut_slice()[index] - } -} - -impl<T> Extend<T> for RepeatedField<T> { - fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) { - self.vec.truncate(self.len); - self.vec.extend(iter); - self.len = self.vec.len(); - } -} - -impl<'a, T: Copy + 'a> Extend<&'a T> for RepeatedField<T> { - fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) { - self.vec.truncate(self.len); - self.vec.extend(iter); - self.len = self.vec.len(); - } -} - -impl<T: fmt::Debug> fmt::Debug for RepeatedField<T> { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.as_ref().fmt(f) - } -} - -#[cfg(feature = "with-serde")] -impl<T: serde::Serialize> serde::Serialize for RepeatedField<T> { - fn serialize<S>( - &self, - serializer: S, - ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error> - where - S: serde::Serializer, - { - self.as_ref().serialize(serializer) - } -} - -#[cfg(feature = "with-serde")] -impl<'de, T: serde::Deserialize<'de> + Default> serde::Deserialize<'de> for RepeatedField<T> { - fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error> - where - D: serde::Deserializer<'de>, - { - Vec::deserialize(deserializer).map(RepeatedField::from) - } -} - -#[cfg(test)] -mod test { - use super::RepeatedField; - - #[test] - fn as_mut_slice() { - let mut v = RepeatedField::new(); - v.push(10); - v.push(20); - v.clear(); - assert_eq!(v.as_mut_slice(), &mut []); - v.push(30); - assert_eq!(v.as_mut_slice(), &mut [30]); - } - - #[test] - fn push_default() { - let mut v = RepeatedField::new(); - v.push("aa".to_string()); - v.push("bb".to_string()); - v.clear(); - assert_eq!("".to_string(), *v.push_default()); - } - - #[test] - fn extend_values() { - let mut r = RepeatedField::new(); - r.push(10); - r.push(20); - r.clear(); - // self-check - assert_eq!(2, r.vec.len()); - r.extend(vec![30, 40]); - assert_eq!(&[30, 40][..], &r); - } - - #[test] - fn extend_copy() { - let mut r = RepeatedField::new(); - r.push(10); - r.push(20); - r.clear(); - // self-check - assert_eq!(2, r.vec.len()); - r.extend(&[30, 40]); - assert_eq!(&[30, 40][..], &r); - } -} |