impl BytePort for PipeBytePort {
fn try_recv(&self, count: uint) -> Option<~[u8]> {
- if vec::uniq_len(&const *self.buf) >= count {
+ if self.buf.len() >= count {
let mut bytes = ::core::util::replace(&mut *self.buf, ~[]);
*self.buf = bytes.slice(count, bytes.len()).to_owned();
bytes.truncate(count);
return Some(bytes);
- } else if vec::uniq_len(&const *self.buf) > 0 {
+ } else if !self.buf.is_empty() {
let mut bytes = ::core::util::replace(&mut *self.buf, ~[]);
assert!(count > bytes.len());
match self.try_recv(count - bytes.len()) {
}
None => return None
}
- } else if vec::uniq_len(&const *self.buf) == 0 {
+ } else /* empty */ {
match self.port.try_recv() {
Some(buf) => {
assert!(!buf.is_empty());
}
None => return None
}
- } else {
- ::core::util::unreachable()
}
}
}
// If possible, copy up to `len` bytes from the internal
// `data.buf` into `buf`
- let nbuffered = vec::uniq_len(&const self.data.buf) -
- self.data.buf_off;
+ let nbuffered = self.data.buf.len() - self.data.buf_off;
let needed = len - count;
if nbuffered > 0 {
unsafe {
}
fn read_byte(&self) -> int {
loop {
- if vec::uniq_len(&const self.data.buf) > self.data.buf_off {
+ if self.data.buf.len() > self.data.buf_off {
let c = self.data.buf[self.data.buf_off];
self.data.buf_off += 1;
return c as int
impl<T:Ord> Container for PriorityQueue<T> {
/// Returns the length of the queue
- fn len(&const self) -> uint { vec::uniq_len(&const self.data) }
+ fn len(&self) -> uint { self.data.len() }
/// Returns true if a queue contains no elements
- fn is_empty(&const self) -> bool { self.len() == 0 }
+ fn is_empty(&self) -> bool { self.len() == 0 }
}
impl<T:Ord> Mutable for PriorityQueue<T> {
}
fn process_msg_block(st: &mut Sha1State) {
assert_eq!(st.h.len(), digest_buf_len);
- assert_eq!(vec::uniq_len(st.work_buf), work_buf_len);
+ assert_eq!(st.work_buf.len(), work_buf_len);
let mut t: int; // Loop counter
let w = st.work_buf;
impl<V> Container for SmallIntMap<V> {
/// Return the number of elements in the map
- fn len(&const self) -> uint {
+ fn len(&self) -> uint {
let mut sz = 0;
- for uint::range(0, vec::uniq_len(&const self.v)) |i| {
+ for uint::range(0, self.v.len()) |i| {
match self.v[i] {
Some(_) => sz += 1,
None => {}
}
/// Return true if the map contains no elements
- fn is_empty(&const self) -> bool { self.len() == 0 }
+ fn is_empty(&self) -> bool { self.len() == 0 }
}
impl<V> Mutable for SmallIntMap<V> {
impl Container for SmallIntSet {
/// Return the number of elements in the map
- fn len(&const self) -> uint {
+ fn len(&self) -> uint {
self.map.len()
}
/// Return true if the map contains no elements
- fn is_empty(&const self) -> bool { self.len() == 0 }
+ fn is_empty(&self) -> bool { self.len() == 0 }
}
impl Mutable for SmallIntSet {
fn print_failures(st: &ConsoleTestState) {
st.out.write_line("\nfailures:");
let mut failures = ~[];
- for uint::range(0, vec::uniq_len(&const st.failures)) |i| {
+ for uint::range(0, st.failures.len()) |i| {
let name = copy st.failures[i].name;
failures.push(name.to_str());
}
fn peek(&self) -> bool {
// It'd be nice to use self.port.each, but that version isn't
// pure.
- for uint::range(0, vec::uniq_len(&const self.ports)) |i| {
+ for uint::range(0, self.ports.len()) |i| {
let port: &pipesy::Port<T> = &self.ports[i];
if port.peek() {
return true;
/// knowledge known is the number of elements contained within.
pub trait Container {
/// Return the number of elements in the container
- fn len(&const self) -> uint;
+ fn len(&self) -> uint;
/// Return true if the container contains no elements
- fn is_empty(&const self) -> bool;
+ fn is_empty(&self) -> bool;
}
/// A trait to represent mutable containers
fn seek(&self, offset: int, whence: SeekStyle) {
let pos = *self.pos;
- let len = vec::uniq_len(&const *self.bytes);
+ let len = self.bytes.len();
*self.pos = seek_in_buf(offset, pos, len, whence);
}
use cast::transmute;
use char;
+use container::Container;
use intrinsic;
use intrinsic::{TyDesc, TyVisitor, visit_tydesc};
use intrinsic::Opaque;
_offset: uint,
inner: *TyDesc)
-> bool {
- match self.var_stk[vec::uniq_len(&const *self.var_stk) - 1] {
+ match self.var_stk[self.var_stk.len() - 1] {
Matched => {
if i != 0 {
self.writer.write_str(", ");
_disr_val: int,
n_fields: uint,
_name: &str) -> bool {
- match self.var_stk[vec::uniq_len(&const *self.var_stk) - 1] {
+ match self.var_stk[self.var_stk.len() - 1] {
Matched => {
if n_fields > 0 {
self.writer.write_char(')');
do (|| {
while total_read < len {
- let slice = vec::mut_slice(*buf, start_len + total_read, buf.len());
+ let len = buf.len();
+ let slice = vec::mut_slice(*buf, start_len + total_read, len);
match self.read(slice) {
Some(nread) => {
total_read += nread;
}
}
-// A botch to tide us over until core and std are fully demuted.
-#[allow(missing_doc)]
-pub fn uniq_len<T>(v: &const ~[T]) -> uint {
- unsafe {
- let v: &~[T] = transmute(v);
- as_const_buf(*v, |_p, len| len)
- }
-}
-
/**
* Creates and initializes an owned vector.
*
}
}
-impl<'self,T> Container for &'self const [T] {
+impl<'self, T> Container for &'self const [T] {
/// Returns true if a vector contains no elements
#[inline]
- fn is_empty(&const self) -> bool {
+ fn is_empty(&self) -> bool {
as_const_buf(*self, |_p, len| len == 0u)
}
/// Returns the length of a vector
#[inline]
- fn len(&const self) -> uint {
+ fn len(&self) -> uint {
as_const_buf(*self, |_p, len| len)
}
+}
+impl<T> Container for ~[T] {
+ /// Returns true if a vector contains no elements
+ #[inline]
+ fn is_empty(&self) -> bool {
+ as_const_buf(*self, |_p, len| len == 0u)
+ }
+
+ /// Returns the length of a vector
+ #[inline]
+ fn len(&self) -> uint {
+ as_const_buf(*self, |_p, len| len)
+ }
}
#[allow(missing_doc)]
projects / rust.git / commitdiff