Implement for Vec, DList, RingBuf. Add MutableSeq to the prelude.
Since the collections traits are in the prelude most consumers of
these methods will continue to work without change.
[breaking-change]
#[allow(experimental)]
mod tests {
use std::clone::Clone;
+ use std::collections::MutableSeq;
use std::comm::channel;
use std::mem::drop;
use std::ops::Drop;
use core::uint;
use std::hash;
-use {Collection, Mutable, Set, MutableSet};
+use {Collection, Mutable, Set, MutableSet, MutableSeq};
use vec::Vec;
use core::fmt;
use core::fmt::Show;
-use Collection;
+use {Collection, MutableSeq};
use vec::Vec;
#[allow(missing_doc)]
use core::mem;
use core::ptr;
-use {Collection, Mutable, Deque};
+use {Collection, Mutable, Deque, MutableSeq};
/// A doubly-linked list.
pub struct DList<T> {
}
}
+impl<T> MutableSeq<T> for DList<T> {
+ fn push(&mut self, elt: T) { self.push_back(elt) }
+ fn pop(&mut self) -> Option<T> { self.pop_back() }
+}
+
impl<T> Default for DList<T> {
#[inline]
fn default() -> DList<T> { DList::new() }
use test::Bencher;
use test;
- use Deque;
+ use {Deque, MutableSeq};
use super::{DList, Node, ListInsertion};
use vec::Vec;
use super::super::{Hash, Writer};
use super::{SipState, hash, hash_with_keys};
+ use MutableSeq;
+
// Hash just the bytes of the slice, without length prefix
struct Bytes<'a>(&'a [u8]);
fn remove(&mut self, value: &T) -> bool;
}
+pub trait MutableSeq<T>: Mutable {
+ fn push(&mut self, t: T);
+ fn pop(&mut self) -> Option<T>;
+}
+
/// A double-ended sequence that allows querying, insertion and deletion at both
/// ends.
///
/// println!("{}", (f, b));
/// }
/// ```
-pub trait Deque<T> : Mutable {
+pub trait Deque<T> : MutableSeq<T> {
/// Provide a reference to the front element, or `None` if the sequence is
/// empty.
///
pub use core::clone; // deriving(Clone)
pub use core::cmp; // deriving(Eq, Ord, etc.)
pub use hash; // deriving(Hash)
+
+ pub mod collections {
+ pub use MutableSeq;
+ }
}
#![macro_escape]
/// Create a `std::vec::Vec` containing the arguments.
+#[cfg(not(test))]
macro_rules! vec(
($($e:expr),*) => ({
+ #[allow(unused_imports)]
+ use std::collections::MutableSeq;
+
+ // leading _ to allow empty construction without a warning.
+ let mut _temp = ::vec::Vec::new();
+ $(_temp.push($e);)*
+ _temp
+ });
+ ($($e:expr),+,) => (vec!($($e),+))
+)
+
+#[cfg(test)]
+macro_rules! vec(
+ ($($e:expr),*) => ({
+ #[allow(unused_imports)]
+ use MutableSeq;
+
// leading _ to allow empty construction without a warning.
let mut _temp = ::vec::Vec::new();
$(_temp.push($e);)*
use core::mem::{zeroed, replace, swap};
use core::ptr;
-use {Collection, Mutable};
+use {Collection, Mutable, MutableSeq};
use slice;
use vec::Vec;
use priority_queue::PriorityQueue;
use vec::Vec;
+ use MutableSeq;
#[test]
fn test_iterator() {
use core::fmt;
use core::iter::RandomAccessIterator;
-use {Deque, Collection, Mutable};
+use {Deque, Collection, Mutable, MutableSeq};
use vec::Vec;
static INITIAL_CAPACITY: uint = 8u; // 2^3
}
}
+impl<T> MutableSeq<T> for RingBuf<T> {
+ fn push(&mut self, t: T) { self.push_back(t) }
+ fn pop(&mut self) -> Option<T> { self.pop_back() }
+}
+
impl<T> Default for RingBuf<T> {
#[inline]
fn default() -> RingBuf<T> { RingBuf::new() }
use core::ptr;
use core::iter::{range_step, MultiplicativeIterator};
-use Collection;
+use {Collection, MutableSeq};
use vec::Vec;
pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
use std::rt;
use slice::*;
- use Mutable;
+ use {Mutable, MutableSeq};
use vec::Vec;
fn square(n: uint) -> uint { n * n }
use test::Bencher;
use vec::Vec;
+ use MutableSeq;
#[bench]
fn iterator(b: &mut Bencher) {
use core::iter::AdditiveIterator;
use core::mem;
-use Collection;
+use {Collection, MutableSeq};
use hash;
use string::String;
use unicode;
use core::ptr;
use core::raw::Slice;
-use {Collection, Mutable};
+use {Collection, Mutable, MutableSeq};
use hash;
use str;
use str::{CharRange, StrAllocating, MaybeOwned, Owned, Slice};
use core::ptr;
use std::hash::{Writer, Hash};
-use {Collection, Mutable, Set, MutableSet, MutableMap, Map};
+use {Collection, Mutable, Set, MutableSet, MutableMap, Map, MutableSeq};
use vec::Vec;
// This is implemented as an AA tree, which is a simplified variation of
use std::rand::Rng;
use std::rand;
- use {Map, MutableMap, Mutable};
+ use {Map, MutableMap, Mutable, MutableSeq};
use super::{TreeMap, TreeNode};
#[test]
use core::ptr;
use core::uint;
-use {Collection, Mutable};
+use {Collection, Mutable, MutableSeq};
use slice::{MutableOrdVector, MutableVectorAllocating, CloneableVector};
use slice::{Items, MutItems};
}
}
- /// Remove the last element from a vector and return it, or `None` if it is
- /// empty.
- ///
- /// # Example
- ///
- /// ```
- /// let mut vec = vec![1i, 2, 3];
- /// assert_eq!(vec.pop(), Some(3));
- /// assert_eq!(vec, vec![1, 2]);
- /// ```
- #[inline]
- pub fn pop(&mut self) -> Option<T> {
- if self.len == 0 {
- None
- } else {
- unsafe {
- self.len -= 1;
- Some(ptr::read(self.as_slice().unsafe_ref(self.len())))
- }
- }
- }
-
- /// Append an element to a vector.
- ///
- /// # Failure
- ///
- /// Fails if the number of elements in the vector overflows a `uint`.
- ///
- /// # Example
- ///
- /// ```
- /// let mut vec = vec![1i, 2];
- /// vec.push(3);
- /// assert_eq!(vec, vec![1, 2, 3]);
- /// ```
- #[inline]
- pub fn push(&mut self, value: T) {
- if mem::size_of::<T>() == 0 {
- // zero-size types consume no memory, so we can't rely on the address space running out
- self.len = self.len.checked_add(&1).expect("length overflow");
- unsafe { mem::forget(value); }
- return
- }
- if self.len == self.cap {
- let old_size = self.cap * mem::size_of::<T>();
- let size = max(old_size, 2 * mem::size_of::<T>()) * 2;
- if old_size > size { fail!("capacity overflow") }
- unsafe {
- self.ptr = alloc_or_realloc(self.ptr, size,
- self.cap * mem::size_of::<T>());
- }
- self.cap = max(self.cap, 2) * 2;
- }
-
- unsafe {
- let end = (self.ptr as *const T).offset(self.len as int) as *mut T;
- ptr::write(&mut *end, value);
- self.len += 1;
- }
- }
-
/// Appends one element to the vector provided. The vector itself is then
/// returned for use again.
///
}
}
+impl<T> MutableSeq<T> for Vec<T> {
+ /// Append an element to a vector.
+ ///
+ /// # Failure
+ ///
+ /// Fails if the number of elements in the vector overflows a `uint`.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// let mut vec = vec!(1i, 2);
+ /// vec.push(3);
+ /// assert_eq!(vec, vec!(1, 2, 3));
+ /// ```
+ #[inline]
+ fn push(&mut self, value: T) {
+ if mem::size_of::<T>() == 0 {
+ // zero-size types consume no memory, so we can't rely on the address space running out
+ self.len = self.len.checked_add(&1).expect("length overflow");
+ unsafe { mem::forget(value); }
+ return
+ }
+ if self.len == self.cap {
+ let old_size = self.cap * mem::size_of::<T>();
+ let size = max(old_size, 2 * mem::size_of::<T>()) * 2;
+ if old_size > size { fail!("capacity overflow") }
+ unsafe {
+ self.ptr = alloc_or_realloc(self.ptr, size,
+ self.cap * mem::size_of::<T>());
+ }
+ self.cap = max(self.cap, 2) * 2;
+ }
+
+ unsafe {
+ let end = (self.ptr as *const T).offset(self.len as int) as *mut T;
+ ptr::write(&mut *end, value);
+ self.len += 1;
+ }
+ }
+
+ /// Remove the last element from a vector and return it, or `None` if it is
+ /// empty.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// let mut vec = vec!(1i, 2, 3);
+ /// assert_eq!(vec.pop(), Some(3));
+ /// assert_eq!(vec, vec!(1, 2));
+ /// ```
+ #[inline]
+ fn pop(&mut self) -> Option<T> {
+ if self.len == 0 {
+ None
+ } else {
+ unsafe {
+ self.len -= 1;
+ Some(ptr::read(self.as_slice().unsafe_ref(self.len())))
+ }
+ }
+ }
+
+}
+
/// An iterator that moves out of a vector.
pub struct MoveItems<T> {
allocation: *mut T, // the block of memory allocated for the vector
use test::Bencher;
use super::{unzip, raw, Vec};
+ use MutableSeq;
+
#[test]
fn test_small_vec_struct() {
assert!(size_of::<Vec<u8>>() == size_of::<uint>() * 3);
use core::prelude::*;
use alloc::boxed::Box;
+use collections::MutableSeq;
use collections::vec::Vec;
use core::atomics;
use core::mem;
use core::prelude::*;
use alloc::boxed::Box;
+use collections::MutableSeq;
use collections::vec::Vec;
use core::kinds::marker;
use core::mem;
#![experimental]
pub use core_collections::{Collection, Mutable, Map, MutableMap};
-pub use core_collections::{Set, MutableSet, Deque};
+pub use core_collections::{Set, MutableSet, Deque, MutableSeq};
pub use core_collections::{Bitv, BitvSet, BTree, DList, EnumSet};
pub use core_collections::{PriorityQueue, RingBuf, SmallIntMap};
pub use core_collections::{TreeMap, TreeSet, TrieMap, TrieSet};
#![allow(missing_doc)]
use clone::Clone;
+use collections::MutableSeq;
use c_str::ToCStr;
use iter::Iterator;
use mem;
// FIXME: Not sure how this should be structured
// FIXME: Iteration should probably be considered separately
-use collections::Collection;
+use collections::{Collection, MutableSeq};
use iter::Iterator;
use option::{Option, Some, None};
use result::{Ok, Err};
use c_str::ToCStr;
use clone::Clone;
-use collections::Collection;
+use collections::{Collection, MutableSeq};
use io::standard_error;
use io::{FilePermission, Write, UnstableFileStat, Open, FileAccess, FileMode};
use io::{IoResult, IoError, FileStat, SeekStyle, Seek, Writer, Reader};
*/
use clone::Clone;
+use collections::MutableSeq;
use comm::{Sender, Receiver, channel};
use io;
use iter::Iterator;
#[cfg(test)] pub use os = realstd::os;
// The test runner requires std::slice::Vector, so re-export std::slice just for it.
#[cfg(test)] pub use slice;
+
+ pub use collections; // vec!() uses MutableSeq
}
#[macro_export]
macro_rules! vec(
($($e:expr),*) => ({
+ #[allow(unused_imports)]
+ use std::collections::MutableSeq;
+
// leading _ to allow empty construction without a warning.
let mut _temp = ::std::vec::Vec::new();
$(_temp.push($e);)*
use char;
use clone::Clone;
-use collections::Collection;
+use collections::{Collection, MutableSeq};
use num::{NumCast, Zero, One, cast, Int};
use num::{Float, FPNaN, FPInfinite, ToPrimitive};
use num;
#![allow(non_snake_case_functions)]
use clone::Clone;
-use collections::Collection;
+use collections::{Collection, MutableSeq};
use fmt;
use io::{IoResult, IoError};
use iter::Iterator;
#![experimental]
-use collections::Collection;
+use collections::{Collection, MutableSeq};
use c_str::CString;
use clone::Clone;
use fmt;
use c_str::{CString, ToCStr};
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
-use collections::Collection;
+use collections::{Collection, MutableSeq};
use from_str::FromStr;
use hash;
use io::Writer;
use c_str::{CString, ToCStr};
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
-use collections::Collection;
+use collections::{Collection, MutableSeq};
use from_str::FromStr;
use hash;
use io::Writer;
#[doc(no_inline)] pub use clone::Clone;
#[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
#[doc(no_inline)] pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
-#[doc(no_inline)] pub use collections::{Collection, Mutable, Map, MutableMap};
+#[doc(no_inline)] pub use collections::{Collection, Mutable, Map, MutableMap, MutableSeq};
#[doc(no_inline)] pub use collections::{Set, MutableSet};
#[doc(no_inline)] pub use iter::{FromIterator, Extendable, ExactSize};
#[doc(no_inline)] pub use iter::{Iterator, DoubleEndedIterator};
use alloc::arc::Arc;
use alloc::heap::{allocate, deallocate};
use alloc::boxed::Box;
-use collections::Vec;
+use collections::{Vec, MutableSeq};
use core::kinds::marker;
use core::mem::{forget, min_align_of, size_of, transmute};
use core::ptr;
use core::kinds::marker;
use core::mem;
use core::ty::Unsafe;
-use collections::Vec;
+use collections::{Vec, MutableSeq};
use mutex;
use comm::{Receiver, Sender, channel};
projects / rust.git / commitdiff