src/repeated.rs - platform/external/rust/crates/protobuf - Git at Google

 #[cfg(feature = "with-serde")]
 use serde;

 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;

 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);
     }
 }
	#[cfg(feature = "with-serde")]
	use serde;

	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;

	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);
	}
	}