squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Fix comment formatting

Browse source
This commit is contained in:
Brendan Zabarauskas 2014-06-16 00:22:51 -07:00 committed by Alex Crichton
parent b84d17d4d7
commit 4c0f8f49f6
1 changed files with 36 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

76
src/libcore/mem.rs
View file

@ -403,10 +403,8 @@ pub fn from_be32(x: u32) -> u32 { ByteOrder::from_big_endian(x) }
#[stable]
pub fn from_be64(x: u64) -> u64 { ByteOrder::from_big_endian(x) }
/**
* Swap the values at two mutable locations of the same type, without
* deinitialising or copying either one.
*/
/// Swap the values at two mutable locations of the same type, without
/// deinitialising or copying either one.
#[inline]
#[stable]
pub fn swap<T>(x: &mut T, y: &mut T) {
@ -425,42 +423,40 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
}
}
/**
* Replace the value at a mutable location with a new one, returning the old
* value, without deinitialising or copying either one.
*
* This is primarily used for transferring and swapping ownership of a value
* in a mutable location. For example, this function allows consumption of
* one field of a struct by replacing it with another value. The normal approach
* doesn't always work:
*
* ```rust,ignore
* struct Buffer<T> { buf: Vec<T> }
*
* impl<T> Buffer<T> {
* fn get_and_reset(&mut self) -> Vec<T> {
* // error: cannot move out of dereference of `&mut`-pointer
* let buf = self.buf;
* self.buf = Vec::new();
* buf
* }
* }
* ```
*
* Note that `T` does not necessarily implement `Clone`, so it can't even
* clone and reset `self.buf`. But `replace` can be used to disassociate
* the original value of `self.buf` from `self`, allowing it to be returned:
*
* ```rust
* # struct Buffer<T> { buf: Vec<T> }
* impl<T> Buffer<T> {
* fn get_and_reset(&mut self) -> Vec<T> {
* use std::mem::replace;
* replace(&mut self.buf, Vec::new())
* }
* }
* ```
*/
/// Replace the value at a mutable location with a new one, returning the old
/// value, without deinitialising or copying either one.
///
/// This is primarily used for transferring and swapping ownership of a value
/// in a mutable location. For example, this function allows consumption of
/// one field of a struct by replacing it with another value. The normal approach
/// doesn't always work:
///
/// ```rust,ignore
/// struct Buffer<T> { buf: Vec<T> }
///
/// impl<T> Buffer<T> {
/// fn get_and_reset(&mut self) -> Vec<T> {
/// // error: cannot move out of dereference of `&mut`-pointer
/// let buf = self.buf;
/// self.buf = Vec::new();
/// buf
/// }
/// }
/// ```
///
/// Note that `T` does not necessarily implement `Clone`, so it can't even
/// clone and reset `self.buf`. But `replace` can be used to disassociate
/// the original value of `self.buf` from `self`, allowing it to be returned:
///
/// ```rust
/// # struct Buffer<T> { buf: Vec<T> }
/// impl<T> Buffer<T> {
/// fn get_and_reset(&mut self) -> Vec<T> {
/// use std::mem::replace;
/// replace(&mut self.buf, Vec::new())
/// }
/// }
/// ```
#[inline]
#[stable]
pub fn replace<T>(dest: &mut T, mut src: T) -> T {