modernize std::deque
* use a proper exported data type with private fields * implement core::container::Container * use the current constructor convention * use explicit self * get rid of DVec and the mutable fields Closes #2343
This commit is contained in:
parent
8d8c25b825
commit
b47e1e9eda
3 changed files with 119 additions and 144 deletions
|
@ -1,4 +1,4 @@
|
||||||
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
|
||||||
// file at the top-level directory of this distribution and at
|
// file at the top-level directory of this distribution and at
|
||||||
// http://rust-lang.org/COPYRIGHT.
|
// http://rust-lang.org/COPYRIGHT.
|
||||||
//
|
//
|
||||||
|
@ -8,145 +8,122 @@
|
||||||
// option. This file may not be copied, modified, or distributed
|
// option. This file may not be copied, modified, or distributed
|
||||||
// except according to those terms.
|
// except according to those terms.
|
||||||
|
|
||||||
//! A deque. Untested as of yet. Likely buggy
|
use core::container::{Container, Mutable};
|
||||||
#[forbid(non_camel_case_types)];
|
|
||||||
|
|
||||||
use core::cmp::Eq;
|
use core::cmp::Eq;
|
||||||
use core::dvec::DVec;
|
|
||||||
use core::dvec;
|
|
||||||
use core::prelude::*;
|
use core::prelude::*;
|
||||||
use core::uint;
|
use core::uint;
|
||||||
use core::vec;
|
use core::vec;
|
||||||
|
|
||||||
pub trait Deque<T> {
|
const initial_capacity: uint = 32u; // 2^5
|
||||||
fn size() -> uint;
|
|
||||||
fn add_front(v: T);
|
pub struct Deque<T> {
|
||||||
fn add_back(v: T);
|
priv nelts: uint,
|
||||||
fn pop_front() -> T;
|
priv lo: uint,
|
||||||
fn pop_back() -> T;
|
priv hi: uint,
|
||||||
fn peek_front() -> T;
|
priv elts: ~[Option<T>]
|
||||||
fn peek_back() -> T;
|
|
||||||
fn get(int) -> T;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// FIXME (#2343) eventually, a proper datatype plus an exported impl would
|
impl<T> Container for Deque<T> {
|
||||||
// be preferrable.
|
pure fn len(&self) -> uint { self.nelts }
|
||||||
pub fn create<T: Copy>() -> Deque<T> {
|
pure fn is_empty(&self) -> bool { self.len() == 0 }
|
||||||
type Cell<T> = Option<T>;
|
}
|
||||||
|
|
||||||
let initial_capacity: uint = 32u; // 2^5
|
impl<T: Copy> Deque<T> {
|
||||||
/**
|
static pure fn new() -> Deque<T> {
|
||||||
* Grow is only called on full elts, so nelts is also len(elts), unlike
|
Deque{nelts: 0, lo: 0, hi: 0,
|
||||||
* elsewhere.
|
elts: vec::from_fn(initial_capacity, |_| None)}
|
||||||
*/
|
|
||||||
fn grow<T: Copy>(nelts: uint, lo: uint, elts: ~[Cell<T>])
|
|
||||||
-> ~[Cell<T>] {
|
|
||||||
let mut elts = elts;
|
|
||||||
assert (nelts == vec::len(elts));
|
|
||||||
let mut rv = ~[];
|
|
||||||
|
|
||||||
let mut i = 0u;
|
|
||||||
let nalloc = uint::next_power_of_two(nelts + 1u);
|
|
||||||
while i < nalloc {
|
|
||||||
if i < nelts {
|
|
||||||
rv.push(elts[(lo + i) % nelts]);
|
|
||||||
} else { rv.push(None); }
|
|
||||||
i += 1u;
|
|
||||||
}
|
|
||||||
|
|
||||||
rv
|
|
||||||
}
|
|
||||||
fn get<T: Copy>(elts: &DVec<Cell<T>>, i: uint) -> T {
|
|
||||||
match (*elts).get_elt(i) { Some(t) => t, _ => fail!() }
|
|
||||||
}
|
}
|
||||||
|
|
||||||
struct Repr<T> {
|
fn add_front(&mut self, t: T) {
|
||||||
mut nelts: uint,
|
let oldlo: uint = self.lo;
|
||||||
mut lo: uint,
|
if self.lo == 0u {
|
||||||
mut hi: uint,
|
self.lo = self.elts.len() - 1u;
|
||||||
elts: DVec<Cell<T>>,
|
} else { self.lo -= 1u; }
|
||||||
|
if self.lo == self.hi {
|
||||||
|
self.elts = grow(self.nelts, oldlo, self.elts);
|
||||||
|
self.lo = self.elts.len() - 1u;
|
||||||
|
self.hi = self.nelts;
|
||||||
|
}
|
||||||
|
self.elts[self.lo] = Some(t);
|
||||||
|
self.nelts += 1u;
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: Copy> Deque<T> for Repr<T> {
|
fn add_back(&mut self, t: T) {
|
||||||
fn size() -> uint { return self.nelts; }
|
if self.lo == self.hi && self.nelts != 0u {
|
||||||
fn add_front(t: T) {
|
self.elts = grow(self.nelts, self.lo, self.elts);
|
||||||
let oldlo: uint = self.lo;
|
self.lo = 0u;
|
||||||
if self.lo == 0u {
|
self.hi = self.nelts;
|
||||||
self.lo = self.elts.len() - 1u;
|
|
||||||
} else { self.lo -= 1u; }
|
|
||||||
if self.lo == self.hi {
|
|
||||||
self.elts.swap(|v| grow(self.nelts, oldlo, v));
|
|
||||||
self.lo = self.elts.len() - 1u;
|
|
||||||
self.hi = self.nelts;
|
|
||||||
}
|
|
||||||
self.elts.set_elt(self.lo, Some(t));
|
|
||||||
self.nelts += 1u;
|
|
||||||
}
|
|
||||||
fn add_back(t: T) {
|
|
||||||
if self.lo == self.hi && self.nelts != 0u {
|
|
||||||
self.elts.swap(|v| grow(self.nelts, self.lo, v));
|
|
||||||
self.lo = 0u;
|
|
||||||
self.hi = self.nelts;
|
|
||||||
}
|
|
||||||
self.elts.set_elt(self.hi, Some(t));
|
|
||||||
self.hi = (self.hi + 1u) % self.elts.len();
|
|
||||||
self.nelts += 1u;
|
|
||||||
}
|
|
||||||
/**
|
|
||||||
* We actually release (turn to none()) the T we're popping so
|
|
||||||
* that we don't keep anyone's refcount up unexpectedly.
|
|
||||||
*/
|
|
||||||
fn pop_front() -> T {
|
|
||||||
let t: T = get(&self.elts, self.lo);
|
|
||||||
self.elts.set_elt(self.lo, None);
|
|
||||||
self.lo = (self.lo + 1u) % self.elts.len();
|
|
||||||
self.nelts -= 1u;
|
|
||||||
return t;
|
|
||||||
}
|
|
||||||
fn pop_back() -> T {
|
|
||||||
if self.hi == 0u {
|
|
||||||
self.hi = self.elts.len() - 1u;
|
|
||||||
} else { self.hi -= 1u; }
|
|
||||||
let t: T = get(&self.elts, self.hi);
|
|
||||||
self.elts.set_elt(self.hi, None);
|
|
||||||
self.nelts -= 1u;
|
|
||||||
return t;
|
|
||||||
}
|
|
||||||
fn peek_front() -> T { return get(&self.elts, self.lo); }
|
|
||||||
fn peek_back() -> T { return get(&self.elts, self.hi - 1u); }
|
|
||||||
fn get(i: int) -> T {
|
|
||||||
let idx = (self.lo + (i as uint)) % self.elts.len();
|
|
||||||
return get(&self.elts, idx);
|
|
||||||
}
|
}
|
||||||
|
self.elts[self.hi] = Some(t);
|
||||||
|
self.hi = (self.hi + 1u) % self.elts.len();
|
||||||
|
self.nelts += 1u;
|
||||||
}
|
}
|
||||||
|
|
||||||
let repr: Repr<T> = Repr {
|
fn pop_front(&mut self) -> T {
|
||||||
nelts: 0u,
|
let t: T = get(self.elts, self.lo);
|
||||||
lo: 0u,
|
self.elts[self.lo] = None;
|
||||||
hi: 0u,
|
self.lo = (self.lo + 1u) % self.elts.len();
|
||||||
elts: dvec::from_vec(vec::from_elem(initial_capacity, None)),
|
self.nelts -= 1u;
|
||||||
};
|
return t;
|
||||||
|
}
|
||||||
|
|
||||||
repr as Deque::<T>
|
fn pop_back(&mut self) -> T {
|
||||||
|
if self.hi == 0u {
|
||||||
|
self.hi = self.elts.len() - 1u;
|
||||||
|
} else { self.hi -= 1u; }
|
||||||
|
let t: T = get(self.elts, self.hi);
|
||||||
|
self.elts[self.hi] = None;
|
||||||
|
self.nelts -= 1u;
|
||||||
|
return t;
|
||||||
|
}
|
||||||
|
|
||||||
|
fn peek_front(&self) -> T { return get(self.elts, self.lo); }
|
||||||
|
|
||||||
|
fn peek_back(&self) -> T { return get(self.elts, self.hi - 1u); }
|
||||||
|
|
||||||
|
fn get(&self, i: int) -> T {
|
||||||
|
let idx = (self.lo + (i as uint)) % self.elts.len();
|
||||||
|
return get(self.elts, idx);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Grow is only called on full elts, so nelts is also len(elts), unlike
|
||||||
|
/// elsewhere.
|
||||||
|
fn grow<T: Copy>(nelts: uint, lo: uint, elts: &[Option<T>]) -> ~[Option<T>] {
|
||||||
|
assert nelts == elts.len();
|
||||||
|
let mut rv = ~[];
|
||||||
|
|
||||||
|
let mut i = 0u;
|
||||||
|
let nalloc = uint::next_power_of_two(nelts + 1u);
|
||||||
|
while i < nalloc {
|
||||||
|
if i < nelts {
|
||||||
|
rv.push(elts[(lo + i) % nelts]);
|
||||||
|
} else { rv.push(None); }
|
||||||
|
i += 1u;
|
||||||
|
}
|
||||||
|
|
||||||
|
rv
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get<T: Copy>(elts: &[Option<T>], i: uint) -> T {
|
||||||
|
match elts[i] { Some(t) => t, _ => fail!() }
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use core::prelude::*;
|
use core::prelude::*;
|
||||||
|
use super::*;
|
||||||
use deque::*;
|
|
||||||
use deque;
|
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_simple() {
|
fn test_simple() {
|
||||||
let d: deque::Deque<int> = deque::create::<int>();
|
let mut d = Deque::new();
|
||||||
assert (d.size() == 0u);
|
assert (d.len() == 0u);
|
||||||
d.add_front(17);
|
d.add_front(17);
|
||||||
d.add_front(42);
|
d.add_front(42);
|
||||||
d.add_back(137);
|
d.add_back(137);
|
||||||
assert (d.size() == 3u);
|
assert (d.len() == 3u);
|
||||||
d.add_back(137);
|
d.add_back(137);
|
||||||
assert (d.size() == 4u);
|
assert (d.len() == 4u);
|
||||||
log(debug, d.peek_front());
|
log(debug, d.peek_front());
|
||||||
assert (d.peek_front() == 42);
|
assert (d.peek_front() == 42);
|
||||||
log(debug, d.peek_back());
|
log(debug, d.peek_back());
|
||||||
|
@ -163,15 +140,15 @@ mod tests {
|
||||||
i = d.pop_back();
|
i = d.pop_back();
|
||||||
log(debug, i);
|
log(debug, i);
|
||||||
assert (i == 17);
|
assert (i == 17);
|
||||||
assert (d.size() == 0u);
|
assert (d.len() == 0u);
|
||||||
d.add_back(3);
|
d.add_back(3);
|
||||||
assert (d.size() == 1u);
|
assert (d.len() == 1u);
|
||||||
d.add_front(2);
|
d.add_front(2);
|
||||||
assert (d.size() == 2u);
|
assert (d.len() == 2u);
|
||||||
d.add_back(4);
|
d.add_back(4);
|
||||||
assert (d.size() == 3u);
|
assert (d.len() == 3u);
|
||||||
d.add_front(1);
|
d.add_front(1);
|
||||||
assert (d.size() == 4u);
|
assert (d.len() == 4u);
|
||||||
log(debug, d.get(0));
|
log(debug, d.get(0));
|
||||||
log(debug, d.get(1));
|
log(debug, d.get(1));
|
||||||
log(debug, d.get(2));
|
log(debug, d.get(2));
|
||||||
|
@ -189,29 +166,29 @@ mod tests {
|
||||||
let c: @int = @64;
|
let c: @int = @64;
|
||||||
let d: @int = @175;
|
let d: @int = @175;
|
||||||
|
|
||||||
let deq: deque::Deque<@int> = deque::create::<@int>();
|
let mut deq = Deque::new();
|
||||||
assert (deq.size() == 0u);
|
assert (deq.len() == 0u);
|
||||||
deq.add_front(a);
|
deq.add_front(a);
|
||||||
deq.add_front(b);
|
deq.add_front(b);
|
||||||
deq.add_back(c);
|
deq.add_back(c);
|
||||||
assert (deq.size() == 3u);
|
assert (deq.len() == 3u);
|
||||||
deq.add_back(d);
|
deq.add_back(d);
|
||||||
assert (deq.size() == 4u);
|
assert (deq.len() == 4u);
|
||||||
assert (deq.peek_front() == b);
|
assert (deq.peek_front() == b);
|
||||||
assert (deq.peek_back() == d);
|
assert (deq.peek_back() == d);
|
||||||
assert (deq.pop_front() == b);
|
assert (deq.pop_front() == b);
|
||||||
assert (deq.pop_back() == d);
|
assert (deq.pop_back() == d);
|
||||||
assert (deq.pop_back() == c);
|
assert (deq.pop_back() == c);
|
||||||
assert (deq.pop_back() == a);
|
assert (deq.pop_back() == a);
|
||||||
assert (deq.size() == 0u);
|
assert (deq.len() == 0u);
|
||||||
deq.add_back(c);
|
deq.add_back(c);
|
||||||
assert (deq.size() == 1u);
|
assert (deq.len() == 1u);
|
||||||
deq.add_front(b);
|
deq.add_front(b);
|
||||||
assert (deq.size() == 2u);
|
assert (deq.len() == 2u);
|
||||||
deq.add_back(d);
|
deq.add_back(d);
|
||||||
assert (deq.size() == 3u);
|
assert (deq.len() == 3u);
|
||||||
deq.add_front(a);
|
deq.add_front(a);
|
||||||
assert (deq.size() == 4u);
|
assert (deq.len() == 4u);
|
||||||
assert (deq.get(0) == a);
|
assert (deq.get(0) == a);
|
||||||
assert (deq.get(1) == b);
|
assert (deq.get(1) == b);
|
||||||
assert (deq.get(2) == c);
|
assert (deq.get(2) == c);
|
||||||
|
@ -219,29 +196,29 @@ mod tests {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn test_parameterized<T: Copy Eq Durable>(a: T, b: T, c: T, d: T) {
|
fn test_parameterized<T: Copy Eq Durable>(a: T, b: T, c: T, d: T) {
|
||||||
let deq: deque::Deque<T> = deque::create::<T>();
|
let mut deq = Deque::new();
|
||||||
assert (deq.size() == 0u);
|
assert (deq.len() == 0u);
|
||||||
deq.add_front(a);
|
deq.add_front(a);
|
||||||
deq.add_front(b);
|
deq.add_front(b);
|
||||||
deq.add_back(c);
|
deq.add_back(c);
|
||||||
assert (deq.size() == 3u);
|
assert (deq.len() == 3u);
|
||||||
deq.add_back(d);
|
deq.add_back(d);
|
||||||
assert (deq.size() == 4u);
|
assert (deq.len() == 4u);
|
||||||
assert deq.peek_front() == b;
|
assert deq.peek_front() == b;
|
||||||
assert deq.peek_back() == d;
|
assert deq.peek_back() == d;
|
||||||
assert deq.pop_front() == b;
|
assert deq.pop_front() == b;
|
||||||
assert deq.pop_back() == d;
|
assert deq.pop_back() == d;
|
||||||
assert deq.pop_back() == c;
|
assert deq.pop_back() == c;
|
||||||
assert deq.pop_back() == a;
|
assert deq.pop_back() == a;
|
||||||
assert (deq.size() == 0u);
|
assert (deq.len() == 0u);
|
||||||
deq.add_back(c);
|
deq.add_back(c);
|
||||||
assert (deq.size() == 1u);
|
assert (deq.len() == 1u);
|
||||||
deq.add_front(b);
|
deq.add_front(b);
|
||||||
assert (deq.size() == 2u);
|
assert (deq.len() == 2u);
|
||||||
deq.add_back(d);
|
deq.add_back(d);
|
||||||
assert (deq.size() == 3u);
|
assert (deq.len() == 3u);
|
||||||
deq.add_front(a);
|
deq.add_front(a);
|
||||||
assert (deq.size() == 4u);
|
assert (deq.len() == 4u);
|
||||||
assert deq.get(0) == a;
|
assert deq.get(0) == a;
|
||||||
assert deq.get(1) == b;
|
assert deq.get(1) == b;
|
||||||
assert deq.get(2) == c;
|
assert deq.get(2) == c;
|
||||||
|
|
|
@ -23,7 +23,6 @@ use std::time;
|
||||||
use std::oldmap;
|
use std::oldmap;
|
||||||
use std::oldmap::Map;
|
use std::oldmap::Map;
|
||||||
use std::oldmap::HashMap;
|
use std::oldmap::HashMap;
|
||||||
use std::deque;
|
|
||||||
use std::deque::Deque;
|
use std::deque::Deque;
|
||||||
use std::par;
|
use std::par;
|
||||||
use core::io::WriterUtil;
|
use core::io::WriterUtil;
|
||||||
|
@ -124,18 +123,18 @@ fn bfs(graph: graph, key: node_id) -> bfs_result {
|
||||||
let mut marks : ~[node_id]
|
let mut marks : ~[node_id]
|
||||||
= vec::from_elem(vec::len(graph), -1i64);
|
= vec::from_elem(vec::len(graph), -1i64);
|
||||||
|
|
||||||
let Q = deque::create();
|
let mut q = Deque::new();
|
||||||
|
|
||||||
Q.add_back(key);
|
q.add_back(key);
|
||||||
marks[key] = key;
|
marks[key] = key;
|
||||||
|
|
||||||
while Q.size() > 0 {
|
while !q.is_empty() {
|
||||||
let t = Q.pop_front();
|
let t = q.pop_front();
|
||||||
|
|
||||||
do graph[t].each() |k| {
|
do graph[t].each() |k| {
|
||||||
if marks[*k] == -1i64 {
|
if marks[*k] == -1i64 {
|
||||||
marks[*k] = t;
|
marks[*k] = t;
|
||||||
Q.add_back(*k);
|
q.add_back(*k);
|
||||||
}
|
}
|
||||||
true
|
true
|
||||||
};
|
};
|
||||||
|
|
|
@ -11,10 +11,9 @@
|
||||||
// except according to those terms.
|
// except according to those terms.
|
||||||
|
|
||||||
extern mod std;
|
extern mod std;
|
||||||
use std::deque;
|
|
||||||
use std::deque::Deque;
|
use std::deque::Deque;
|
||||||
|
|
||||||
pub fn main() {
|
pub fn main() {
|
||||||
let Q = deque::create();
|
let mut q = Deque::new();
|
||||||
Q.add_back(10);
|
q.add_back(10);
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in a new issue