mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

std::vec: remove unnecessary count parameter on {bytes,

Browse Source 
raw}::copy_memory.

Slices carry their length with them, so we can just use that
information.
This commit is contained in:
Huon Wilson 2013-12-15 22:23:11 +11:00
parent 8f6df87c1d
commit f97040a93b
9 changed files with 33 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/libextra/uuid.rs
View File

@ -175,7 +175,7 @@ impl Uuid {
pub fn new_v4() -> Uuid {
let ub = rand::task_rng().gen_vec(16);
let mut uuid = Uuid{ bytes: [0, .. 16] };
vec::bytes::copy_memory(uuid.bytes, ub, 16);
vec::bytes::copy_memory(uuid.bytes, ub);
uuid.set_variant(VariantRFC4122);
uuid.set_version(Version4Random);
uuid
@ -202,7 +202,7 @@ impl Uuid {
fields.data1 = to_be32(d1 as i32) as u32;
fields.data2 = to_be16(d2 as i16) as u16;
fields.data3 = to_be16(d3 as i16) as u16;
vec::bytes::copy_memory(fields.data4, d4, 8);
vec::bytes::copy_memory(fields.data4, d4);
unsafe {
transmute(fields)
@ -220,7 +220,7 @@ impl Uuid {
let mut uuid = Uuid{ bytes: [0, .. 16] };
unsafe {
vec::raw::copy_memory(uuid.bytes, b, 16);
vec::raw::copy_memory(uuid.bytes, b);
}
Some(uuid)
}
@ -442,11 +442,7 @@ impl Zero for Uuid {
impl Clone for Uuid {
/// Returns a copy of the UUID
fn clone(&self) -> Uuid {
let mut clone = Uuid{ bytes: [0, .. 16] };
vec::bytes::copy_memory(clone.bytes, self.bytes, 16);
clone
}
fn clone(&self) -> Uuid { *self }
}
impl FromStr for Uuid {
@ -509,7 +505,7 @@ impl rand::Rand for Uuid {
fn rand<R: rand::Rng>(rng: &mut R) -> Uuid {
let ub = rng.gen_vec(16);
let mut uuid = Uuid{ bytes: [0, .. 16] };
vec::bytes::copy_memory(uuid.bytes, ub, 16);
vec::bytes::copy_memory(uuid.bytes, ub);
uuid.set_variant(VariantRFC4122);
uuid.set_version(Version4Random);
uuid

9
src/librustc/util/sha2.rs
View File

@ -136,16 +136,14 @@ impl FixedBuffer for FixedBuffer64 {
if input.len() >= buffer_remaining {
copy_memory(
self.buffer.mut_slice(self.buffer_idx, size),
input.slice_to(buffer_remaining),
buffer_remaining);
input.slice_to(buffer_remaining));
self.buffer_idx = 0;
func(self.buffer);
i += buffer_remaining;
} else {
copy_memory(
self.buffer.mut_slice(self.buffer_idx, self.buffer_idx + input.len()),
input,
input.len());
input);
self.buffer_idx += input.len();
return;
}
@ -164,8 +162,7 @@ impl FixedBuffer for FixedBuffer64 {
let input_remaining = input.len() - i;
copy_memory(
self.buffer.mut_slice(0, input_remaining),
input.slice_from(i),
input.len() - i);
input.slice_from(i));
self.buffer_idx += input_remaining;
}

9
src/librustpkg/sha1.rs
View File

@ -149,16 +149,14 @@ impl FixedBuffer for FixedBuffer64 {
if input.len() >= buffer_remaining {
copy_memory(
self.buffer.mut_slice(self.buffer_idx, size),
input.slice_to(buffer_remaining),
buffer_remaining);
input.slice_to(buffer_remaining));
self.buffer_idx = 0;
func(self.buffer);
i += buffer_remaining;
} else {
copy_memory(
self.buffer.mut_slice(self.buffer_idx, self.buffer_idx + input.len()),
input,
input.len());
input);
self.buffer_idx += input.len();
return;
}
@ -177,8 +175,7 @@ impl FixedBuffer for FixedBuffer64 {
let input_remaining = input.len() - i;
copy_memory(
self.buffer.mut_slice(0, input_remaining),
input.slice_from(i),
input.len() - i);
input.slice_from(i));
self.buffer_idx += input_remaining;
}

2
src/libstd/c_str.rs
View File

@ -293,7 +293,7 @@ impl<'a> ToCStr for &'a [u8] {
unsafe fn with_c_str<T>(v: &[u8], checked: bool, f: |*libc::c_char| -> T) -> T {
if v.len() < BUF_LEN {
let mut buf: [u8, .. BUF_LEN] = intrinsics::uninit();
vec::bytes::copy_memory(buf, v, v.len());
vec::bytes::copy_memory(buf, v);
buf[v.len()] = 0;
buf.as_mut_buf(|buf, _| {

4
src/libstd/io/buffered.rs
View File

@ -122,7 +122,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
return None;
}
let nread = num::min(available.len(), buf.len());
vec::bytes::copy_memory(buf, available, nread);
vec::bytes::copy_memory(buf, available.slice_to(nread));
nread
};
self.pos += nread;
@ -185,7 +185,7 @@ impl<W: Writer> Writer for BufferedWriter<W> {
self.inner.write(buf);
} else {
let dst = self.buf.mut_slice_from(self.pos);
vec::bytes::copy_memory(dst, buf, buf.len());
vec::bytes::copy_memory(dst, buf);
self.pos += buf.len();
}
}

2
src/libstd/io/comm_adapters.rs
View File

@ -57,7 +57,7 @@ impl<P: GenericPort<~[u8]>> Reader for PortReader<P> {
let dst = buf.mut_slice_from(num_read);
let src = prev.slice_from(self.pos);
let count = cmp::min(dst.len(), src.len());
bytes::copy_memory(dst, src, count);
bytes::copy_memory(dst, src.slice_to(count));
num_read += count;
self.pos += count;
},

10
src/libstd/io/mem.rs
View File

@ -58,8 +58,7 @@ impl Writer for MemWriter {
// Do the necessary writes
if left.len() > 0 {
vec::bytes::copy_memory(self.buf.mut_slice_from(self.pos),
left, left.len());
vec::bytes::copy_memory(self.buf.mut_slice_from(self.pos), left);
}
if right.len() > 0 {
self.buf.push_all(right);
@ -116,7 +115,7 @@ impl Reader for MemReader {
let input = self.buf.slice(self.pos, self.pos + write_len);
let output = buf.mut_slice(0, write_len);
assert_eq!(input.len(), output.len());
vec::bytes::copy_memory(output, input, write_len);
vec::bytes::copy_memory(output, input);
}
self.pos += write_len;
assert!(self.pos <= self.buf.len());
@ -175,8 +174,7 @@ impl<'a> Writer for BufWriter<'a> {
return;
}
vec::bytes::copy_memory(self.buf.mut_slice_from(self.pos),
buf, buf.len());
vec::bytes::copy_memory(self.buf.mut_slice_from(self.pos), buf);
self.pos += buf.len();
}
}
@ -222,7 +220,7 @@ impl<'a> Reader for BufReader<'a> {
let input = self.buf.slice(self.pos, self.pos + write_len);
let output = buf.mut_slice(0, write_len);
assert_eq!(input.len(), output.len());
vec::bytes::copy_memory(output, input, write_len);
vec::bytes::copy_memory(output, input);
}
self.pos += write_len;
assert!(self.pos <= self.buf.len());

30
src/libstd/vec.rs
View File

@ -1631,7 +1631,7 @@ impl<T> OwnedVector<T> for ~[T] {
{
let first_slice = self.slice(0, 1);
let last_slice = self.slice(next_ln, ln);
raw::copy_memory(cast::transmute(last_slice), first_slice, 1);
raw::copy_memory(cast::transmute(last_slice), first_slice);
}
// Memcopy everything to the left one element
@ -1639,8 +1639,7 @@ impl<T> OwnedVector<T> for ~[T] {
let init_slice = self.slice(0, next_ln);
let tail_slice = self.slice(1, ln);
raw::copy_memory(cast::transmute(init_slice),
tail_slice,
next_ln);
tail_slice);
}
// Set the new length. Now the vector is back to normal
@ -2312,18 +2311,14 @@ pub mod raw {
/**
* Copies data from one vector to another.
*
* Copies `count` bytes from `src` to `dst`. The source and destination
* may overlap.
* Copies `src` to `dst`. The source and destination may overlap.
*/
#[inline]
pub unsafe fn copy_memory<T>(dst: &mut [T], src: &[T],
count: uint) {
assert!(dst.len() >= count);
assert!(src.len() >= count);
dst.as_mut_buf(|p_dst, _len_dst| {
src.as_imm_buf(|p_src, _len_src| {
ptr::copy_memory(p_dst, p_src, count)
pub unsafe fn copy_memory<T>(dst: &mut [T], src: &[T]) {
dst.as_mut_buf(|p_dst, len_dst| {
src.as_imm_buf(|p_src, len_src| {
assert!(len_dst >= len_src)
ptr::copy_memory(p_dst, p_src, len_src)
})
})
}
@ -2419,13 +2414,12 @@ pub mod bytes {
/**
* Copies data from one vector to another.
*
* Copies `count` bytes from `src` to `dst`. The source and destination
* may overlap.
* Copies `src` to `dst`. The source and destination may overlap.
*/
#[inline]
pub fn copy_memory(dst: &mut [u8], src: &[u8], count: uint) {
pub fn copy_memory(dst: &mut [u8], src: &[u8]) {
// Bound checks are done at vec::raw::copy_memory.
unsafe { vec::raw::copy_memory(dst, src, count) }
unsafe { vec::raw::copy_memory(dst, src) }
}
/**
@ -3651,7 +3645,7 @@ mod tests {
unsafe {
let mut a = [1, 2, 3, 4];
let b = [1, 2, 3, 4, 5];
raw::copy_memory(a, b, 5);
raw::copy_memory(a, b);
}
}

5
src/test/bench/shootout-fasta-redux.rs
View File

@ -95,11 +95,10 @@ impl RepeatFasta {
let mut buf = vec::from_elem(alu_len + LINE_LEN, 0u8);
let alu: &[u8] = self.alu.as_bytes();
copy_memory(buf, alu, alu_len);
copy_memory(buf, alu);
let buf_len = buf.len();
copy_memory(buf.mut_slice(alu_len, buf_len),
alu,
LINE_LEN);
alu.slice_to(LINE_LEN));
let mut pos = 0;
let mut bytes;