use core::borrow::Borrow;
use core::iter::IntoIterator;
use core::fmt;
use ordered_map;
use {PhfHash, OrderedMap};
pub struct OrderedSet<T: 'static> {
#[doc(hidden)]
pub map: OrderedMap<T, ()>,
}
impl<T> fmt::Debug for OrderedSet<T> where T: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_set().entries(self).finish()
}
}
impl<T> OrderedSet<T> {
pub fn len(&self) -> usize {
self.map.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn get_key<U: ?Sized>(&self, key: &U) -> Option<&T>
where U: Eq + PhfHash,
T: Borrow<U>
{
self.map.get_key(key)
}
pub fn get_index<U: ?Sized>(&self, key: &U) -> Option<usize>
where U: Eq + PhfHash,
T: Borrow<U>
{
self.map.get_index(key)
}
pub fn index(&self, index: usize) -> Option<&T> {
self.map.index(index).map(|(k, &())| k)
}
pub fn contains<U: ?Sized>(&self, value: &U) -> bool
where U: Eq + PhfHash,
T: Borrow<U>
{
self.map.contains_key(value)
}
pub fn iter<'a>(&'a self) -> Iter<'a, T> {
Iter { iter: self.map.keys() }
}
}
impl<T> OrderedSet<T> where T: Eq + PhfHash {
#[inline]
pub fn is_disjoint(&self, other: &OrderedSet<T>) -> bool {
!self.iter().any(|value| other.contains(value))
}
#[inline]
pub fn is_subset(&self, other: &OrderedSet<T>) -> bool {
self.iter().all(|value| other.contains(value))
}
#[inline]
pub fn is_superset(&self, other: &OrderedSet<T>) -> bool {
other.is_subset(self)
}
}
impl<'a, T> IntoIterator for &'a OrderedSet<T> {
type Item = &'a T;
type IntoIter = Iter<'a, T>;
fn into_iter(self) -> Iter<'a, T> {
self.iter()
}
}
pub struct Iter<'a, T: 'a> {
iter: ordered_map::Keys<'a, T, ()>,
}
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
#[inline]
fn next(&mut self) -> Option<&'a T> {
self.iter.next()
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a T> {
self.iter.next_back()
}
}
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}