pub struct AATreeSet<T> { /* private fields */ }
Expand description
A set based on an AA-Tree.
See AATreeMap
’s documentation for a detailed discussion of this collection’s performance benefits and drawbacks.
It is a logic error for an item to be modified in such a way that the item’s ordering relative to any
other item, as determined by the Ord
trait, changes while it is in the set. This is normally only possible
through Cell
, RefCell
, global state, I/O, or unsafe code.
Example
This example is adopted from BTreeSet
’s documentation:
use aatree::AATreeSet;
let mut books = AATreeSet::new();
// Add some books.
books.insert("A Dance With Dragons");
books.insert("To Kill a Mockingbird");
books.insert("The Odyssey");
books.insert("The Great Gatsby");
// Check for a specific one
if !books.contains("The Winds of Winter") {
println!("We have {} books, but The Winds of Winter ain't one.", books.len());
}
// Remove a book.
books.remove("The Odyssey");
// Iterate over everything.
for book in &books {
println!("{}", book);
}
Implementations
sourceimpl<T: Ord> AATreeSet<T>
impl<T: Ord> AATreeSet<T>
sourcepub fn insert(&mut self, value: T) -> bool
pub fn insert(&mut self, value: T) -> bool
Adds a value to the set.
If the set did already contain this value, the entry is not updated, and
false
is returned.
Example
let mut set = AATreeSet::new();
set.insert(42);
set.insert(42);
assert_eq!(set.len(), 1);
sourcepub fn first(&self) -> Option<&T>
pub fn first(&self) -> Option<&T>
Returns the first/smallest element of the set.
Example
let mut set = AATreeSet::new();
assert!(set.first().is_none());
set.insert(42);
set.insert(44);
set.insert(40);
assert_eq!(set.first(), Some(&40));
pub fn smallest(&self) -> Option<&T>
Use first() instead
sourcepub fn last(&self) -> Option<&T>
pub fn last(&self) -> Option<&T>
Returns the last/largest element of the set.
Example
let mut set = AATreeSet::new();
assert!(set.last().is_none());
set.insert(42);
set.insert(44);
set.insert(40);
assert_eq!(set.last(), Some(&44));
pub fn largest(&self) -> Option<&T>
Use last() instead
sourcepub fn pop_first(&mut self) -> Option<T>
pub fn pop_first(&mut self) -> Option<T>
Remove and return the first/smallest element of the set.
Example
let mut set = AATreeSet::new();
assert_eq!(set.pop_first(), None);
set.insert(42);
set.insert(44);
set.insert(40);
assert_eq!(set.pop_first(), Some(40));
assert_eq!(set.pop_first(), Some(42));
assert_eq!(set.pop_first(), Some(44));
assert_eq!(set.pop_first(), None);
pub fn pop_smallest(&mut self) -> Option<T>
Use pop_first() instead
sourcepub fn pop_last(&mut self) -> Option<T>
pub fn pop_last(&mut self) -> Option<T>
Remove and return the last/largest element of the set.
Example
let mut set = AATreeSet::new();
assert_eq!(set.pop_last(), None);
set.insert(42);
set.insert(44);
set.insert(40);
assert_eq!(set.pop_last(), Some(44));
assert_eq!(set.pop_last(), Some(42));
assert_eq!(set.pop_last(), Some(40));
assert_eq!(set.pop_last(), None);
pub fn pop_largest(&mut self) -> Option<T>
Use pop_last() instead
sourcepub fn contains<Q>(&self, value: &Q) -> bool where
T: Borrow<Q> + Ord,
Q: Ord + ?Sized,
pub fn contains<Q>(&self, value: &Q) -> bool where
T: Borrow<Q> + Ord,
Q: Ord + ?Sized,
Returns true
if the set contains an element with the given value.
Example
let mut set = AATreeSet::new();
set.insert(43);
assert_eq!(set.contains(&42), false);
set.insert(42);
assert_eq!(set.contains(&42), true);
sourcepub fn first_at_or_after<Q>(&self, value: &Q) -> Option<&T> where
T: Borrow<Q> + Ord,
Q: Ord + ?Sized,
pub fn first_at_or_after<Q>(&self, value: &Q) -> Option<&T> where
T: Borrow<Q> + Ord,
Q: Ord + ?Sized,
Returns the first/smallest element of the set that is greater or equal to x
.
Example
let mut set = AATreeSet::new();
assert!(set.first_at_or_after(&41).is_none());
set.insert(42);
set.insert(44);
set.insert(40);
assert_eq!(set.first_at_or_after(&41), Some(&42));
pub fn smallest_geq_than<Q>(&self, value: &Q) -> Option<&T> where
T: Borrow<Q> + Ord,
Q: Ord + ?Sized,
Use first_at_or_after() instead
sourcepub fn last_at_or_before<Q>(&self, value: &Q) -> Option<&T> where
T: Borrow<Q> + Ord,
Q: Ord + ?Sized,
pub fn last_at_or_before<Q>(&self, value: &Q) -> Option<&T> where
T: Borrow<Q> + Ord,
Q: Ord + ?Sized,
Returns the last/largest element of the set that is smaller or equal to x
.
Example
let mut set = AATreeSet::new();
assert!(set.last_at_or_before(&43).is_none());
set.insert(42);
set.insert(44);
set.insert(40);
assert_eq!(set.last_at_or_before(&43), Some(&42));
pub fn largest_leq_than<Q>(&self, value: &Q) -> Option<&T> where
T: Borrow<Q> + Ord,
Q: Ord + ?Sized,
Use last_at_or_before() instead
Trait Implementations
sourceimpl<T: Ord> FromIterator<T> for AATreeSet<T>
impl<T: Ord> FromIterator<T> for AATreeSet<T>
sourcefn from_iter<I>(iter: I) -> Self where
I: IntoIterator<Item = T>,
fn from_iter<I>(iter: I) -> Self where
I: IntoIterator<Item = T>,
Creates a value from an iterator. Read more
sourceimpl<'a, T> IntoIterator for &'a AATreeSet<T>
impl<'a, T> IntoIterator for &'a AATreeSet<T>
sourceimpl<T> IntoIterator for AATreeSet<T>
impl<T> IntoIterator for AATreeSet<T>
Auto Trait Implementations
impl<T> RefUnwindSafe for AATreeSet<T> where
T: RefUnwindSafe,
impl<T> Send for AATreeSet<T> where
T: Send,
impl<T> Sync for AATreeSet<T> where
T: Sync,
impl<T> Unpin for AATreeSet<T>
impl<T> UnwindSafe for AATreeSet<T> where
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more