use core::uint;
use std::hash;
+use {Collection, Mutable, Set, MutableSet};
use vec::Vec;
#[deriving(Clone)]
use std::rand::Rng;
use test::Bencher;
+ use {Set, Mutable, MutableSet};
use bitv::{Bitv, SmallBitv, BigBitv, BitvSet, from_bools, from_fn,
from_bytes};
use bitv;
use core::fmt;
use core::fmt::Show;
+use Collection;
use vec::Vec;
#[allow(missing_doc)]
//! Container traits for collections
-use core::prelude::*;
-
-/// A double-ended sequence that allows querying, insertion and deletion at both ends.
-pub trait Deque<T> : Mutable {
- /// Provide a reference to the front element, or None if the sequence is empty
- fn front<'a>(&'a self) -> Option<&'a T>;
-
- /// Provide a mutable reference to the front element, or None if the sequence is empty
- fn front_mut<'a>(&'a mut self) -> Option<&'a mut T>;
-
- /// Provide a reference to the back element, or None if the sequence is empty
- fn back<'a>(&'a self) -> Option<&'a T>;
-
- /// Provide a mutable reference to the back element, or None if the sequence is empty
- fn back_mut<'a>(&'a mut self) -> Option<&'a mut T>;
-
- /// Insert an element first in the sequence
- fn push_front(&mut self, elt: T);
-
- /// Insert an element last in the sequence
- fn push_back(&mut self, elt: T);
-
- /// Remove the last element and return it, or None if the sequence is empty
- fn pop_back(&mut self) -> Option<T>;
-
- /// Remove the first element and return it, or None if the sequence is empty
- fn pop_front(&mut self) -> Option<T>;
-}
-
#[cfg(test)]
pub mod bench {
use std::prelude::*;
use std::rand;
use std::rand::Rng;
use test::Bencher;
+ use MutableMap;
pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
map: &mut M,
})
}
}
+
//! The DList allows pushing and popping elements at either end.
//!
//! DList implements the trait Deque. It should be imported with `use
-//! collections::deque::Deque`.
+//! collections::Deque`.
// DList is constructed like a singly-linked list over the field `next`.
// including the last link being None; each Node owns its `next` field.
use core::mem;
use core::ptr;
-use deque::Deque;
+use {Collection, Mutable, Deque};
/// A doubly-linked list.
pub struct DList<T> {
use test::Bencher;
use test;
- use deque::Deque;
+ use Deque;
use super::{DList, Node, ListInsertion};
use vec::Vec;
#[cfg(test)] #[phase(syntax, link)] extern crate std;
#[cfg(test)] #[phase(syntax, link)] extern crate log;
+use core::prelude::*;
+
+pub use core::collections::Collection;
pub use bitv::{Bitv, BitvSet};
pub use btree::BTree;
-pub use deque::Deque;
pub use dlist::DList;
pub use enum_set::EnumSet;
pub use priority_queue::PriorityQueue;
pub mod bitv;
pub mod btree;
-pub mod deque;
pub mod dlist;
pub mod enum_set;
pub mod priority_queue;
// Internal unicode fiddly bits for the str module
mod unicode;
-// FIXME(#14008) should this actually exist, or should a method be added?
-fn expect<T>(a: core::option::Option<T>, b: &str) -> T {
- match a {
- core::option::Some(a) => a,
- core::option::None => fail!("{}", b),
+mod deque;
+
+/// A trait to represent mutable containers
+pub trait Mutable: Collection {
+ /// Clear the container, removing all values.
+ fn clear(&mut self);
+}
+
+/// A map is a key-value store where values may be looked up by their keys. This
+/// trait provides basic operations to operate on these stores.
+pub trait Map<K, V>: Collection {
+ /// Return a reference to the value corresponding to the key
+ fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
+
+ /// Return true if the map contains a value for the specified key
+ #[inline]
+ fn contains_key(&self, key: &K) -> bool {
+ self.find(key).is_some()
+ }
+}
+
+/// This trait provides basic operations to modify the contents of a map.
+pub trait MutableMap<K, V>: Map<K, V> + Mutable {
+ /// Insert a key-value pair into the map. An existing value for a
+ /// key is replaced by the new value. Return true if the key did
+ /// not already exist in the map.
+ #[inline]
+ fn insert(&mut self, key: K, value: V) -> bool {
+ self.swap(key, value).is_none()
+ }
+
+ /// Remove a key-value pair from the map. Return true if the key
+ /// was present in the map, otherwise false.
+ #[inline]
+ fn remove(&mut self, key: &K) -> bool {
+ self.pop(key).is_some()
+ }
+
+ /// Insert a key-value pair from the map. If the key already had a value
+ /// present in the map, that value is returned. Otherwise None is returned.
+ fn swap(&mut self, k: K, v: V) -> Option<V>;
+
+ /// Removes a key from the map, returning the value at the key if the key
+ /// was previously in the map.
+ fn pop(&mut self, k: &K) -> Option<V>;
+
+ /// Return a mutable reference to the value corresponding to the key
+ fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V>;
+}
+
+/// A set is a group of objects which are each distinct from one another. This
+/// trait represents actions which can be performed on sets to iterate over
+/// them.
+pub trait Set<T>: Collection {
+ /// Return true if the set contains a value
+ fn contains(&self, value: &T) -> bool;
+
+ /// Return true if the set has no elements in common with `other`.
+ /// This is equivalent to checking for an empty intersection.
+ fn is_disjoint(&self, other: &Self) -> bool;
+
+ /// Return true if the set is a subset of another
+ fn is_subset(&self, other: &Self) -> bool;
+
+ /// Return true if the set is a superset of another
+ fn is_superset(&self, other: &Self) -> bool {
+ other.is_subset(self)
}
+
+ // FIXME #8154: Add difference, sym. difference, intersection and union iterators
+}
+
+/// This trait represents actions which can be performed on sets to mutate
+/// them.
+pub trait MutableSet<T>: Set<T> + Mutable {
+ /// Add a value to the set. Return true if the value was not already
+ /// present in the set.
+ fn insert(&mut self, value: T) -> bool;
+
+ /// Remove a value from the set. Return true if the value was
+ /// present in the set.
+ fn remove(&mut self, value: &T) -> bool;
+}
+
+/// A double-ended sequence that allows querying, insertion and deletion at both
+/// ends.
+pub trait Deque<T> : Mutable {
+ /// Provide a reference to the front element, or None if the sequence is
+ /// empty
+ fn front<'a>(&'a self) -> Option<&'a T>;
+
+ /// Provide a mutable reference to the front element, or None if the
+ /// sequence is empty
+ fn front_mut<'a>(&'a mut self) -> Option<&'a mut T>;
+
+ /// Provide a reference to the back element, or None if the sequence is
+ /// empty
+ fn back<'a>(&'a self) -> Option<&'a T>;
+
+ /// Provide a mutable reference to the back element, or None if the sequence
+ /// is empty
+ fn back_mut<'a>(&'a mut self) -> Option<&'a mut T>;
+
+ /// Insert an element first in the sequence
+ fn push_front(&mut self, elt: T);
+
+ /// Insert an element last in the sequence
+ fn push_back(&mut self, elt: T);
+
+ /// Remove the last element and return it, or None if the sequence is empty
+ fn pop_back(&mut self) -> Option<T>;
+
+ /// Remove the first element and return it, or None if the sequence is empty
+ fn pop_front(&mut self) -> Option<T>;
}
// FIXME(#14344) this shouldn't be necessary
use core::mem::{zeroed, replace, swap};
use core::ptr;
+use {Collection, Mutable};
use slice;
use vec::Vec;
//! A double-ended queue implemented as a circular buffer
//!
//! RingBuf implements the trait Deque. It should be imported with `use
-//! collections::deque::Deque`.
+//! collections::Deque`.
use core::prelude::*;
use core::fmt;
use core::iter::RandomAccessIterator;
-use deque::Deque;
+use {Deque, Collection, Mutable};
use vec::Vec;
static INITIAL_CAPACITY: uint = 8u; // 2^3
use test::Bencher;
use test;
- use deque::Deque;
+ use {Deque, Mutable};
use super::RingBuf;
use vec::Vec;
use core::mem;
use core::ptr;
use core::iter::{range_step, MultiplicativeIterator};
+
+use Collection;
use vec::Vec;
pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
let len = self.len();
let data_size = len.checked_mul(&mem::size_of::<T>());
- let data_size = ::expect(data_size, "overflow in to_owned()");
+ let data_size = data_size.expect("overflow in to_owned()");
let size = mem::size_of::<RawVec<()>>().checked_add(&data_size);
- let size = ::expect(size, "overflow in to_owned()");
+ let size = size.expect("overflow in to_owned()");
unsafe {
// this should pass the real required alignment
use std::rt;
use slice::*;
+ use Mutable;
use vec::Vec;
fn square(n: uint) -> uint { n * n }
use core::iter::{Enumerate, FilterMap};
use core::mem::replace;
+use {Collection, Mutable, Map, MutableMap};
use {vec, slice};
use vec::Vec;
}
pub fn get<'a>(&'a self, key: &uint) -> &'a V {
- ::expect(self.find(key), "key not present")
+ self.find(key).expect("key not present")
}
/// An iterator visiting all key-value pairs in ascending order by the keys.
mod test_map {
use std::prelude::*;
+ use {Map, MutableMap, Mutable};
use super::SmallIntMap;
#[test]
use core::iter::AdditiveIterator;
use core::mem;
+use Collection;
use hash;
use string::String;
use vec::Vec;
use core::ptr;
use core::raw::Slice;
+use {Collection, Mutable};
use hash;
use str;
use str::{CharRange, StrAllocating};
use std::prelude::*;
use test::Bencher;
+ use Mutable;
use str::{Str, StrSlice};
use super::String;
use core::mem::{replace, swap};
use core::ptr;
+use {Collection, Mutable, Set, MutableSet, MutableMap, Map};
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 super::{TreeMap, TreeNode};
#[test]
#[cfg(test)]
mod bench {
- use std::prelude::*;
use test::Bencher;
use super::TreeMap;
mod test_set {
use std::prelude::*;
+ use {Set, MutableSet, Mutable, MutableMap};
use super::{TreeMap, TreeSet};
#[test]
use core::mem;
use core::uint;
+use {Collection, Mutable, Map, MutableMap, Set, MutableSet};
use slice::{Items, MutItems};
use slice;
use std::iter::range_step;
use std::uint;
+ use {MutableMap, Map};
use super::{TrieMap, TrieNode, Internal, External, Nothing};
fn check_integrity<T>(trie: &TrieNode<T>) {
use std::rand::{weak_rng, Rng};
use test::Bencher;
+ use MutableMap;
use super::TrieMap;
#[bench]
use std::prelude::*;
use std::uint;
+ use {MutableSet, Set};
use super::TrieSet;
#[test]
use core::ptr;
use core::uint;
+use {Collection, Mutable};
use slice::{MutableOrdVector, OwnedVector, MutableVectorAllocating};
use slice::{Items, MutItems};
} else if capacity == 0 {
Vec::new()
} else {
- let size = ::expect(capacity.checked_mul(&mem::size_of::<T>()),
- "capacity overflow");
+ let size = capacity.checked_mul(&mem::size_of::<T>())
+ .expect("capacity overflow");
let ptr = unsafe { allocate(size, mem::min_align_of::<T>()) };
Vec { len: 0, cap: capacity, ptr: ptr as *mut T }
}
if mem::size_of::<T>() == 0 { return }
if capacity > self.cap {
- let size = ::expect(capacity.checked_mul(&mem::size_of::<T>()),
- "capacity overflow");
+ let size = capacity.checked_mul(&mem::size_of::<T>())
+ .expect("capacity overflow");
unsafe {
self.ptr = alloc_or_realloc(self.ptr, size,
self.cap * mem::size_of::<T>());
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 = ::expect(self.len.checked_add(&1), "length overflow");
+ self.len = self.len.checked_add(&1).expect("length overflow");
unsafe { mem::forget(value); }
return
}
fn from_vec(mut v: Vec<T>) -> ~[T] {
let len = v.len();
let data_size = len.checked_mul(&mem::size_of::<T>());
- let data_size = ::expect(data_size, "overflow in from_vec()");
+ let data_size = data_size.expect("overflow in from_vec()");
let size = mem::size_of::<RawVec<()>>().checked_add(&data_size);
- let size = ::expect(size, "overflow in from_vec()");
+ let size = size.expect("overflow in from_vec()");
// In a post-DST world, we can attempt to reuse the Vec allocation by calling
// shrink_to_fit() on it. That may involve a reallocation+memcpy, but that's no
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//! Traits for generic collections (including `Map` and `Set`)
-
-use option::Option;
+//! Traits for generic collections
/// A trait to represent the abstract idea of a container. The only concrete
/// knowledge known is the number of elements contained within.
self.len() == 0
}
}
-
-/// A trait to represent mutable containers
-pub trait Mutable: Collection {
- /// Clear the container, removing all values.
- fn clear(&mut self);
-}
-
-/// A map is a key-value store where values may be looked up by their keys. This
-/// trait provides basic operations to operate on these stores.
-pub trait Map<K, V>: Collection {
- /// Return a reference to the value corresponding to the key
- fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
-
- /// Return true if the map contains a value for the specified key
- #[inline]
- fn contains_key(&self, key: &K) -> bool {
- self.find(key).is_some()
- }
-}
-
-/// This trait provides basic operations to modify the contents of a map.
-pub trait MutableMap<K, V>: Map<K, V> + Mutable {
- /// Insert a key-value pair into the map. An existing value for a
- /// key is replaced by the new value. Return true if the key did
- /// not already exist in the map.
- #[inline]
- fn insert(&mut self, key: K, value: V) -> bool {
- self.swap(key, value).is_none()
- }
-
- /// Remove a key-value pair from the map. Return true if the key
- /// was present in the map, otherwise false.
- #[inline]
- fn remove(&mut self, key: &K) -> bool {
- self.pop(key).is_some()
- }
-
- /// Insert a key-value pair from the map. If the key already had a value
- /// present in the map, that value is returned. Otherwise None is returned.
- fn swap(&mut self, k: K, v: V) -> Option<V>;
-
- /// Removes a key from the map, returning the value at the key if the key
- /// was previously in the map.
- fn pop(&mut self, k: &K) -> Option<V>;
-
- /// Return a mutable reference to the value corresponding to the key
- fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V>;
-}
-
-/// A set is a group of objects which are each distinct from one another. This
-/// trait represents actions which can be performed on sets to iterate over
-/// them.
-pub trait Set<T>: Collection {
- /// Return true if the set contains a value
- fn contains(&self, value: &T) -> bool;
-
- /// Return true if the set has no elements in common with `other`.
- /// This is equivalent to checking for an empty intersection.
- fn is_disjoint(&self, other: &Self) -> bool;
-
- /// Return true if the set is a subset of another
- fn is_subset(&self, other: &Self) -> bool;
-
- /// Return true if the set is a superset of another
- fn is_superset(&self, other: &Self) -> bool {
- other.is_subset(self)
- }
-
- // FIXME #8154: Add difference, sym. difference, intersection and union iterators
-}
-
-/// This trait represents actions which can be performed on sets to mutate
-/// them.
-pub trait MutableSet<T>: Set<T> + Mutable {
- /// Add a value to the set. Return true if the value was not already
- /// present in the set.
- fn insert(&mut self, value: T) -> bool;
-
- /// Remove a value from the set. Return true if the value was
- /// present in the set.
- fn remove(&mut self, value: &T) -> bool;
-}
use clone::Clone;
use cmp::{max, Eq, Equiv, PartialEq};
-use container::{Container, Mutable, Set, MutableSet, Map, MutableMap};
+use collections::{Collection, Mutable, Set, MutableSet, Map, MutableMap};
use default::Default;
use fmt::Show;
use fmt;
}
}
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Container for HashMap<K, V, H> {
+impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Collection for HashMap<K, V, H> {
/// Return the number of elements in the map
fn len(&self) -> uint { self.table.size() }
}
use super::HashSet;
use slice::ImmutableEqVector;
- use std::collections::Collection;
+ use collections::Collection;
#[test]
fn test_disjoint() {
//! ```
use cmp::{PartialEq, Eq};
-use collections::HashMap;
-use container::{Container, Mutable, MutableMap};
+use collections::{HashMap, Collection, Mutable, MutableMap};
use fmt;
use hash::Hash;
use iter::{range, Iterator};
* Collection types.
*/
-pub use core_collections::{Bitv, BitvSet, BTree, Deque, DList, EnumSet};
+pub use core_collections::{Collection, Mutable, Map, MutableMap};
+pub use core_collections::{Set, MutableSet, Deque};
+pub use core_collections::{Bitv, BitvSet, BTree, DList, EnumSet};
pub use core_collections::{PriorityQueue, RingBuf, SmallIntMap};
pub use core_collections::{TreeMap, TreeSet, TrieMap, TrieSet};
-pub use core_collections::{bitv, btree, deque, dlist, enum_set};
+pub use core_collections::{bitv, btree, dlist, enum_set};
pub use core_collections::{priority_queue, ringbuf, smallintmap, treemap, trie};
pub use self::hashmap::{HashMap, HashSet};
pub use core::char;
pub use core::clone;
#[cfg(not(test))] pub use core::cmp;
-pub use core::collections;
pub use core::default;
pub use core::finally;
pub use core::intrinsics;
use c_str::{CString, ToCStr};
use clone::Clone;
use cmp::{PartialEq, Eq};
-use container::Container;
+use collections::Collection;
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 container::{Container, Mutable, Map, MutableMap};
-#[doc(no_inline)] pub use container::{Set, MutableSet};
+#[doc(no_inline)] pub use collections::{Collection, Mutable, Map, MutableMap};
+#[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};
#[doc(no_inline)] pub use iter::{RandomAccessIterator, CloneableIterator};
mod imp {
extern crate libc;
- use container::Container;
+ use core_collections::Collection;
use io::{IoResult, IoError};
use mem;
use ops::Drop;
//! A wrapper around any Reader to treat it as an RNG.
-use container::Container;
+use collections::Collection;
use io::Reader;
use rand::Rng;
use result::{Ok, Err};
#[allow(dead_code, uppercase_variables)]
mod imp {
use c_str::CString;
- use container::Container;
+ use core_collections::Collection;
use intrinsics;
use io::{IoResult, Writer};
use libc;
let x: Box<HashMap<int, int>> = box HashMap::new();
let x: Box<Map<int, int>> = x;
let y: Box<Map<uint, int>> = box x;
- //~^ ERROR failed to find an implementation of trait core::collections::Map<uint,int>
- // for ~core::collections::Map<int,int>:Send
+ //~^ ERROR failed to find an implementation of trait collections::Map<uint,int>
+ // for ~collections::Map<int,int>:Send
}
projects / rust.git / commitdiff