Skip to content

Commit a6945f2

Browse files
borsbors
committed
auto merge of #4993 : thestinger/rust/deque, r=graydon
Closes #3748 and #2343.
2 parents 9ea05a4 + 8b38e07 commit a6945f2

File tree

3 files changed

+145
-167
lines changed

3 files changed

+145
-167
lines changed

‎src/libstd/deque.rs

+138-158
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
1+
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
22
// file at the top-level directory of this distribution and at
33
// http://rust-lang.org/COPYRIGHT.
44
//
@@ -8,178 +8,158 @@
88
// option. This file may not be copied, modified, or distributed
99
// except according to those terms.
1010

11-
//! A deque. Untested as of yet. Likely buggy
12-
#[forbid(non_camel_case_types)];
13-
11+
use core::container::{Container, Mutable};
1412
use core::cmp::Eq;
15-
use core::dvec::DVec;
16-
use core::dvec;
1713
use core::prelude::*;
1814
use core::uint;
1915
use core::vec;
2016

21-
pub trait Deque<T> {
22-
fn size() -> uint;
23-
fn add_front(v: T);
24-
fn add_back(v: T);
25-
fn pop_front() -> T;
26-
fn pop_back() -> T;
27-
fn peek_front() -> T;
28-
fn peek_back() -> T;
29-
fn get(int) -> T;
17+
const initial_capacity: uint = 32u; // 2^5
18+
19+
pub struct Deque<T> {
20+
priv nelts: uint,
21+
priv lo: uint,
22+
priv hi: uint,
23+
priv elts: ~[Option<T>]
3024
}
3125

32-
// FIXME (#2343) eventually, a proper datatype plus an exported impl would
33-
// be preferrable.
34-
pub fn create<T: Copy>() -> Deque<T> {
35-
type Cell<T> = Option<T>;
26+
impl<T> Container for Deque<T> {
27+
pure fn len(&self) -> uint { self.nelts }
28+
pure fn is_empty(&self) -> bool { self.len() == 0 }
29+
}
3630

37-
let initial_capacity: uint = 32u; // 2^5
38-
/**
39-
* Grow is only called on full elts, so nelts is also len(elts), unlike
40-
* elsewhere.
41-
*/
42-
fn grow<T: Copy>(nelts: uint, lo: uint, elts: ~[Cell<T>])
43-
-> ~[Cell<T>] {
44-
let mut elts = elts;
45-
assert (nelts == vec::len(elts));
46-
let mut rv = ~[];
31+
impl<T> Mutable for Deque<T> {
32+
fn clear(&mut self) {
33+
for vec::each_mut(self.elts) |x| { *x = None }
34+
self.nelts = 0;
35+
self.lo = 0;
36+
self.hi = 0;
37+
}
38+
}
4739

48-
let mut i = 0u;
49-
let nalloc = uint::next_power_of_two(nelts + 1u);
50-
while i < nalloc {
51-
if i < nelts {
52-
rv.push(elts[(lo + i) % nelts]);
53-
} else { rv.push(None); }
54-
i += 1u;
55-
}
40+
impl<T> Deque<T> {
41+
static pure fn new() -> Deque<T> {
42+
Deque{nelts: 0, lo: 0, hi: 0,
43+
elts: vec::from_fn(initial_capacity, |_| None)}
44+
}
45+
46+
fn peek_front(&self) -> &self/T { get(self.elts, self.lo) }
47+
fn peek_back(&self) -> &self/T { get(self.elts, self.hi - 1u) }
5648

57-
rv
49+
fn get(&self, i: int) -> &self/T {
50+
let idx = (self.lo + (i as uint)) % self.elts.len();
51+
get(self.elts, idx)
5852
}
59-
fn get<T: Copy>(elts: &DVec<Cell<T>>, i: uint) -> T {
60-
match (*elts).get_elt(i) { Some(t) => t, _ => fail!() }
53+
54+
fn pop_front(&mut self) -> T {
55+
let mut result = self.elts[self.lo].swap_unwrap();
56+
self.lo = (self.lo + 1u) % self.elts.len();
57+
self.nelts -= 1u;
58+
result
6159
}
6260

63-
struct Repr<T> {
64-
mut nelts: uint,
65-
mut lo: uint,
66-
mut hi: uint,
67-
elts: DVec<Cell<T>>,
61+
fn pop_back(&mut self) -> T {
62+
if self.hi == 0u {
63+
self.hi = self.elts.len() - 1u;
64+
} else { self.hi -= 1u; }
65+
let mut result = self.elts[self.hi].swap_unwrap();
66+
self.elts[self.hi] = None;
67+
self.nelts -= 1u;
68+
result
6869
}
6970

70-
impl<T: Copy> Deque<T> for Repr<T> {
71-
fn size() -> uint { return self.nelts; }
72-
fn add_front(t: T) {
73-
let oldlo: uint = self.lo;
74-
if self.lo == 0u {
75-
self.lo = self.elts.len() - 1u;
76-
} else { self.lo -= 1u; }
77-
if self.lo == self.hi {
78-
self.elts.swap(|v| grow(self.nelts, oldlo, v));
79-
self.lo = self.elts.len() - 1u;
80-
self.hi = self.nelts;
81-
}
82-
self.elts.set_elt(self.lo, Some(t));
83-
self.nelts += 1u;
84-
}
85-
fn add_back(t: T) {
86-
if self.lo == self.hi && self.nelts != 0u {
87-
self.elts.swap(|v| grow(self.nelts, self.lo, v));
88-
self.lo = 0u;
89-
self.hi = self.nelts;
90-
}
91-
self.elts.set_elt(self.hi, Some(t));
92-
self.hi = (self.hi + 1u) % self.elts.len();
93-
self.nelts += 1u;
94-
}
95-
/**
96-
* We actually release (turn to none()) the T we're popping so
97-
* that we don't keep anyone's refcount up unexpectedly.
98-
*/
99-
fn pop_front() -> T {
100-
let t: T = get(&self.elts, self.lo);
101-
self.elts.set_elt(self.lo, None);
102-
self.lo = (self.lo + 1u) % self.elts.len();
103-
self.nelts -= 1u;
104-
return t;
105-
}
106-
fn pop_back() -> T {
107-
if self.hi == 0u {
108-
self.hi = self.elts.len() - 1u;
109-
} else { self.hi -= 1u; }
110-
let t: T = get(&self.elts, self.hi);
111-
self.elts.set_elt(self.hi, None);
112-
self.nelts -= 1u;
113-
return t;
71+
fn add_front(&mut self, t: T) {
72+
let oldlo = self.lo;
73+
if self.lo == 0u {
74+
self.lo = self.elts.len() - 1u;
75+
} else { self.lo -= 1u; }
76+
if self.lo == self.hi {
77+
self.elts = grow(self.nelts, oldlo, self.elts);
78+
self.lo = self.elts.len() - 1u;
79+
self.hi = self.nelts;
11480
}
115-
fn peek_front() -> T { return get(&self.elts, self.lo); }
116-
fn peek_back() -> T { return get(&self.elts, self.hi - 1u); }
117-
fn get(i: int) -> T {
118-
let idx = (self.lo + (i as uint)) % self.elts.len();
119-
return get(&self.elts, idx);
81+
self.elts[self.lo] = Some(t);
82+
self.nelts += 1u;
83+
}
84+
85+
fn add_back(&mut self, t: T) {
86+
if self.lo == self.hi && self.nelts != 0u {
87+
self.elts = grow(self.nelts, self.lo, self.elts);
88+
self.lo = 0u;
89+
self.hi = self.nelts;
12090
}
91+
self.elts[self.hi] = Some(t);
92+
self.hi = (self.hi + 1u) % self.elts.len();
93+
self.nelts += 1u;
94+
}
95+
}
96+
97+
/// Grow is only called on full elts, so nelts is also len(elts), unlike
98+
/// elsewhere.
99+
fn grow<T>(nelts: uint, lo: uint, elts: &mut [Option<T>]) -> ~[Option<T>] {
100+
assert nelts == elts.len();
101+
let mut rv = ~[];
102+
103+
do vec::grow_fn(&mut rv, nelts + 1) |i| {
104+
let mut element = None;
105+
element <-> elts[(lo + i) % nelts];
106+
element
121107
}
122108

123-
let repr: Repr<T> = Repr {
124-
nelts: 0u,
125-
lo: 0u,
126-
hi: 0u,
127-
elts: dvec::from_vec(vec::from_elem(initial_capacity, None)),
128-
};
109+
rv
110+
}
129111

130-
repr as Deque::<T>
112+
fn get<T>(elts: &r/[Option<T>], i: uint) -> &r/T {
113+
match elts[i] { Some(ref t) => t, _ => fail!() }
131114
}
132115

133116
#[cfg(test)]
134117
mod tests {
135-
use core::prelude::*;
136-
137-
use deque::*;
138-
use deque;
118+
use super::*;
139119

140120
#[test]
141121
fn test_simple() {
142-
let d: deque::Deque<int> = deque::create::<int>();
143-
assert (d.size() == 0u);
122+
let mut d = Deque::new();
123+
assert d.len() == 0u;
144124
d.add_front(17);
145125
d.add_front(42);
146126
d.add_back(137);
147-
assert (d.size() == 3u);
127+
assert d.len() == 3u;
148128
d.add_back(137);
149-
assert (d.size() == 4u);
129+
assert d.len() == 4u;
150130
log(debug, d.peek_front());
151-
assert (d.peek_front() == 42);
131+
assert *d.peek_front() == 42;
152132
log(debug, d.peek_back());
153-
assert (d.peek_back() == 137);
133+
assert *d.peek_back() == 137;
154134
let mut i: int = d.pop_front();
155135
log(debug, i);
156-
assert (i == 42);
136+
assert i == 42;
157137
i = d.pop_back();
158138
log(debug, i);
159-
assert (i == 137);
139+
assert i == 137;
160140
i = d.pop_back();
161141
log(debug, i);
162-
assert (i == 137);
142+
assert i == 137;
163143
i = d.pop_back();
164144
log(debug, i);
165-
assert (i == 17);
166-
assert (d.size() == 0u);
145+
assert i == 17;
146+
assert d.len() == 0u;
167147
d.add_back(3);
168-
assert (d.size() == 1u);
148+
assert d.len() == 1u;
169149
d.add_front(2);
170-
assert (d.size() == 2u);
150+
assert d.len() == 2u;
171151
d.add_back(4);
172-
assert (d.size() == 3u);
152+
assert d.len() == 3u;
173153
d.add_front(1);
174-
assert (d.size() == 4u);
154+
assert d.len() == 4u;
175155
log(debug, d.get(0));
176156
log(debug, d.get(1));
177157
log(debug, d.get(2));
178158
log(debug, d.get(3));
179-
assert (d.get(0) == 1);
180-
assert (d.get(1) == 2);
181-
assert (d.get(2) == 3);
182-
assert (d.get(3) == 4);
159+
assert *d.get(0) == 1;
160+
assert *d.get(1) == 2;
161+
assert *d.get(2) == 3;
162+
assert *d.get(3) == 4;
183163
}
184164

185165
#[test]
@@ -189,63 +169,63 @@ mod tests {
189169
let c: @int = @64;
190170
let d: @int = @175;
191171

192-
let deq: deque::Deque<@int> = deque::create::<@int>();
193-
assert (deq.size() == 0u);
172+
let mut deq = Deque::new();
173+
assert deq.len() == 0;
194174
deq.add_front(a);
195175
deq.add_front(b);
196176
deq.add_back(c);
197-
assert (deq.size() == 3u);
177+
assert deq.len() == 3;
198178
deq.add_back(d);
199-
assert (deq.size() == 4u);
200-
assert (deq.peek_front() == b);
201-
assert (deq.peek_back() == d);
202-
assert (deq.pop_front() == b);
203-
assert (deq.pop_back() == d);
204-
assert (deq.pop_back() == c);
205-
assert (deq.pop_back() == a);
206-
assert (deq.size() == 0u);
179+
assert deq.len() == 4;
180+
assert *deq.peek_front() == b;
181+
assert *deq.peek_back() == d;
182+
assert deq.pop_front() == b;
183+
assert deq.pop_back() == d;
184+
assert deq.pop_back() == c;
185+
assert deq.pop_back() == a;
186+
assert deq.len() == 0;
207187
deq.add_back(c);
208-
assert (deq.size() == 1u);
188+
assert deq.len() == 1;
209189
deq.add_front(b);
210-
assert (deq.size() == 2u);
190+
assert deq.len() == 2;
211191
deq.add_back(d);
212-
assert (deq.size() == 3u);
192+
assert deq.len() == 3;
213193
deq.add_front(a);
214-
assert (deq.size() == 4u);
215-
assert (deq.get(0) == a);
216-
assert (deq.get(1) == b);
217-
assert (deq.get(2) == c);
218-
assert (deq.get(3) == d);
194+
assert deq.len() == 4;
195+
assert *deq.get(0) == a;
196+
assert *deq.get(1) == b;
197+
assert *deq.get(2) == c;
198+
assert *deq.get(3) == d;
219199
}
220200

221201
fn test_parameterized<T: Copy Eq Durable>(a: T, b: T, c: T, d: T) {
222-
let deq: deque::Deque<T> = deque::create::<T>();
223-
assert (deq.size() == 0u);
202+
let mut deq = Deque::new();
203+
assert deq.len() == 0;
224204
deq.add_front(a);
225205
deq.add_front(b);
226206
deq.add_back(c);
227-
assert (deq.size() == 3u);
207+
assert deq.len() == 3;
228208
deq.add_back(d);
229-
assert (deq.size() == 4u);
230-
assert deq.peek_front() == b;
231-
assert deq.peek_back() == d;
209+
assert deq.len() == 4;
210+
assert *deq.peek_front() == b;
211+
assert *deq.peek_back() == d;
232212
assert deq.pop_front() == b;
233213
assert deq.pop_back() == d;
234214
assert deq.pop_back() == c;
235215
assert deq.pop_back() == a;
236-
assert (deq.size() == 0u);
216+
assert deq.len() == 0;
237217
deq.add_back(c);
238-
assert (deq.size() == 1u);
218+
assert deq.len() == 1;
239219
deq.add_front(b);
240-
assert (deq.size() == 2u);
220+
assert deq.len() == 2;
241221
deq.add_back(d);
242-
assert (deq.size() == 3u);
222+
assert deq.len() == 3;
243223
deq.add_front(a);
244-
assert (deq.size() == 4u);
245-
assert deq.get(0) == a;
246-
assert deq.get(1) == b;
247-
assert deq.get(2) == c;
248-
assert deq.get(3) == d;
224+
assert deq.len() == 4;
225+
assert *deq.get(0) == a;
226+
assert *deq.get(1) == b;
227+
assert *deq.get(2) == c;
228+
assert *deq.get(3) == d;
249229
}
250230

251231
#[deriving_eq]

0 commit comments

Comments
 (0)