assert!(i < self.nbits);
let w = i / uint::BITS;
let b = i % uint::BITS;
- let x = self.storage.get(w) & (1 << b);
+ let x = self.storage[w] & (1 << b);
x != 0
}
let w = i / uint::BITS;
let b = i % uint::BITS;
let flag = 1 << b;
- *self.storage.get_mut(w) = if x { *self.storage.get(w) | flag }
- else { *self.storage.get(w) & !flag };
+ *self.storage.get_mut(w) = if x { self.storage[w] | flag }
+ else { self.storage[w] & !flag };
}
/// Set all bits to 1.
fn clone_from(&mut self, source: &Bitv) {
self.nbits = source.nbits;
self.storage.reserve(source.storage.len());
- for (i, w) in self.storage.mut_iter().enumerate() { *w = *source.storage.get(i); }
+ for (i, w) in self.storage.mut_iter().enumerate() { *w = source.storage[i]; }
}
}
self_bitv.reserve(other_bitv.capacity());
// Apply values
for (i, w) in other_bitv.mask_words(0) {
- let old = *self_bitv.storage.get(i);
+ let old = self_bitv.storage[i];
let new = f(old, w);
*self_bitv.storage.get_mut(i) = new;
}
// one Bitv might be longer than the other
let word_idx = self.next_idx / uint::BITS;
let w1 = if word_idx < s_bitv.storage.len() {
- *s_bitv.storage.get(word_idx)
+ s_bitv.storage[word_idx]
} else { 0 };
let w2 = if word_idx < o_bitv.storage.len() {
- *o_bitv.storage.get(word_idx)
+ o_bitv.storage[word_idx]
} else { 0 };
self.current_word = (self.merge)(w1, w2);
}
midpoint = 0;
}
loop {
- let order = self.elts.get(midpoint).key.cmp(&k);
+ let order = self.elts[midpoint].key.cmp(&k);
match order {
Equal => {
return None;
}
Greater => {
if midpoint > 0 {
- if self.elts.get(midpoint - 1).key.cmp(&k) == Less {
+ if self.elts[midpoint - 1].key.cmp(&k) == Less {
return Some(midpoint);
}
else {
}
Less => {
if midpoint + 1 < self.elts.len() {
- if self.elts.get(midpoint + 1).key.cmp(&k) == Greater {
+ if self.elts[midpoint + 1].key.cmp(&k) == Greater {
return Some(midpoint);
}
else {
if self.elts.len() < other.elts.len() {
return Less;
}
- self.elts.get(0).cmp(other.elts.get(0))
+ self.elts[0].cmp(&other.elts[0])
}
}
midpoint = 0u;
}
loop {
- let order = self.elts.get(midpoint).key.cmp(&k);
+ let order = self.elts[midpoint].key.cmp(&k);
match order {
Equal => {
return None;
}
Greater => {
if midpoint > 0 {
- if self.elts.get(midpoint - 1).key.cmp(&k) == Less {
+ if self.elts[midpoint - 1].key.cmp(&k) == Less {
return Some(midpoint);
}
else {
}
Less => {
if midpoint + 1 < self.elts.len() {
- if self.elts.get(midpoint + 1).key.cmp(&k) == Greater {
+ if self.elts[midpoint + 1].key.cmp(&k) == Greater {
return Some(midpoint);
}
else {
Some(i) => {
if i == self.elts.len() {
let new_outcome = self.clone().rightmost_child.insert(k.clone(),
- v.clone(),
- ub.clone());
+ v.clone(),
+ ub.clone());
new_branch = new_outcome.clone().val0();
outcome = new_outcome.val1();
}
else {
- let new_outcome = self.elts.get(i).left.clone().insert(k.clone(),
- v.clone(),
- ub.clone());
+ let new_outcome = self.elts[i].left.clone().insert(k.clone(),
+ v.clone(),
+ ub.clone());
new_branch = new_outcome.clone().val0();
outcome = new_outcome.val1();
}
//If we have a new branch node, attempt to insert it into the tree
//as with the key-value pair, then check to see if the node is overfull.
BranchNode(branch) => {
- let new_elt = branch.elts.get(0).clone();
+ let new_elt = branch.elts[0].clone();
let new_elt_index = self.bsearch_branch(new_elt.clone().key);
match new_elt_index {
None => {
if self.elts.len() < other.elts.len() {
return Less;
}
- self.elts.get(0).cmp(other.elts.get(0))
+ self.elts[0].cmp(&other.elts[0])
}
}
impl<A> DoubleEndedIterator<A> for MoveItems<A> {
#[inline]
- fn next_back(&mut self) -> Option<A> { self.list.pop_back() }
+ fn next_back(&mut self) -> Option<A> { self.list.pop() }
}
impl<A> FromIterator<A> for DList<A> {
impl<A> Extendable<A> for DList<A> {
fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
- for elt in iterator { self.push_back(elt); }
+ for elt in iterator { self.push(elt); }
}
}
///
/// ```
pub fn top<'a>(&'a self) -> Option<&'a T> {
- if self.is_empty() { None } else { Some(self.data.get(0)) }
+ if self.is_empty() { None } else { Some(&self.data[0]) }
}
#[deprecated="renamed to `top`"]
while pos > start {
let parent = (pos - 1) >> 1;
- if new > *self.data.get(parent) {
+ if new > self.data[parent] {
let x = replace(self.data.get_mut(parent), zeroed());
ptr::write(self.data.get_mut(pos), x);
pos = parent;
let mut child = 2 * pos + 1;
while child < end {
let right = child + 1;
- if right < end && !(*self.data.get(child) > *self.data.get(right)) {
+ if right < end && !(self.data[child] > self.data[right]) {
child = right;
}
let x = replace(self.data.get_mut(child), zeroed());
impl<T> Deque<T> for RingBuf<T> {
/// Return a reference to the first element in the RingBuf
fn front<'a>(&'a self) -> Option<&'a T> {
- if self.nelts > 0 { Some(self.get(0)) } else { None }
+ if self.nelts > 0 { Some(&self[0]) } else { None }
}
/// Return a mutable reference to the first element in the RingBuf
/// Return a reference to the last element in the RingBuf
fn back<'a>(&'a self) -> Option<&'a T> {
- if self.nelts > 0 { Some(self.get(self.nelts - 1)) } else { None }
+ if self.nelts > 0 { Some(&self[self.nelts - 1]) } else { None }
}
/// Return a mutable reference to the last element in the RingBuf
#[deprecated = "prefer using indexing, e.g., ringbuf[0]"]
pub fn get<'a>(&'a self, i: uint) -> &'a T {
let idx = self.raw_index(i);
- match *self.elts.get(idx) {
+ match self.elts[idx] {
None => fail!(),
Some(ref v) => v
}
impl<A> Index<uint, A> for RingBuf<A> {
#[inline]
+ #[allow(deprecated)]
fn index<'a>(&'a self, i: &uint) -> &'a A {
self.get(*i)
}
impl<A> Extendable<A> for RingBuf<A> {
fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
for elt in iterator {
- self.push_back(elt);
+ self.push(elt);
}
}
}
let max = self.sdir.iter().map(|&x| x).enumerate()
.filter(|&(i, sd)|
new_pos(i, sd.dir) < self.sdir.len() &&
- self.sdir.get(new_pos(i, sd.dir)).size < sd.size)
+ self.sdir[new_pos(i, sd.dir)].size < sd.size)
.max_by(|&(_, sd)| sd.size);
match max {
Some((i, sd)) => {
/// Return a reference to the value corresponding to the key.
fn find<'a>(&'a self, key: &uint) -> Option<&'a V> {
if *key < self.v.len() {
- match *self.v.get(*key) {
+ match self.v[*key] {
Some(ref value) => Some(value),
None => None
}
impl<V> Index<uint, V> for SmallIntMap<V> {
#[inline]
+ #[allow(deprecated)]
fn index<'a>(&'a self, i: &uint) -> &'a V {
self.get(i)
}
match self.buffer.as_slice().head() {
Some(&(c, 0)) => {
self.sorted = false;
- self.buffer.shift();
+ self.buffer.remove(0);
return Some(c);
}
Some(&(c, _)) if self.sorted => {
- self.buffer.shift();
+ self.buffer.remove(0);
return Some(c);
}
_ => self.sorted = false
self.sorted = true;
}
- match self.buffer.shift() {
+ match self.buffer.remove(0) {
Some((c, 0)) => {
self.sorted = false;
Some(c)
for (j, tc) in t.chars().enumerate() {
- let next = *dcol.get(j + 1);
+ let next = dcol[j + 1];
if sc == tc {
*dcol.get_mut(j + 1) = current;
} else {
*dcol.get_mut(j + 1) = cmp::min(current, next);
- *dcol.get_mut(j + 1) = cmp::min(*dcol.get(j + 1),
- *dcol.get(j)) + 1;
+ *dcol.get_mut(j + 1) = cmp::min(dcol[j + 1],
+ dcol[j]) + 1;
}
current = next;
}
}
- return *dcol.get(tlen);
+ return dcol[tlen];
}
/// An Iterator over the string in Unicode Normalization Form D
/// }
/// ```
pub unsafe fn shift_byte(&mut self) -> Option<u8> {
- self.vec.shift()
+ self.vec.remove(0)
}
/// Removes the first character from the string buffer and returns it.
impl<T> Index<uint,T> for Vec<T> {
#[inline]
+ #[allow(deprecated)] // allow use of get
fn index<'a>(&'a self, index: &uint) -> &'a T {
self.get(*index)
}
projects / rust.git / commitdiff