Struct sdset::set::Set

#[repr(transparent)]
pub struct Set<T>(_);

Represent a slice which contains types that are sorted and deduplicated (akin to str).

This is an unsized type, meaning that it must always be used behind a pointer like & or Box. For an owned version of this type, see SetBuf.

Methods

impl<T> Set<T>

pub fn new(slice: &[T]) -> Result<&Self, Error> where
    T: Ord, 

Construct a Set only if it is sorted and deduplicated.

use sdset::{Set, Error};

let slice = &[1, 2, 4, 6, 7];
let set = Set::new(slice)?;

// this slice is not sorted!
let slice = &[1, 2, 4, 7, 6];
let set = Set::new(slice);

assert_eq!(set, Err(Error::NotSort));

pub fn new_unchecked(slice: &[T]) -> &Self

Construct a Set without checking it.

use sdset::{Set, Error};

// this slice is not sorted
let slice = &[1, 2, 4, 7, 6];

// but we can still create a Set, so be careful!
let set = Set::new_unchecked(slice);

pub fn range<K: ?Sized, R>(&self, range: R) -> &Self where
    K: Ord,
    R: RangeBounds<K>,
    T: Borrow<K>, 

Returns a Set containing all the values in the given range.

This function uses exponential searching internally because it is verified that the elements are ordered.

use std::ops::Bound::{Excluded, Included};
use sdset::{Set, Error};

let set = Set::new(&[1, 2, 4, 6, 7])?;

let subset = set.range(2..=6);
assert_eq!(subset.as_slice(), &[2, 4, 6]);

let subset = set.range(3..5);
assert_eq!(subset.as_slice(), &[4]);

let subset = set.range((Excluded(&2), Included(&7)));
assert_eq!(subset.as_slice(), &[4, 6, 7]);

pub fn exponential_search(&self, elem: &T) -> Result<usize, usize> where
    T: Ord, 

Exponential searches this sorted slice for a given element.

If the value is found then Ok is returned, containing the index of the matching element; if the value is not found then Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See the exponential_search documentation for more details.

pub fn exponential_search_by<F>(&self, f: F) -> Result<usize, usize> where
    F: FnMut(&T) -> Ordering, 

Binary searches this sorted slice with a comparator function.

The comparator function should implement an order consistent with the sort order of the underlying slice, returning an order code that indicates whether its argument is Less, Equal or Greater the desired target.

If the value is found then Ok is returned, containing the index of the matching element; if the value is not found then Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See the exponential_search_by documentation for more details.

pub fn exponential_search_by_key<B, F>(
    &self,
    b: &B,
    f: F
) -> Result<usize, usize> where
    F: FnMut(&T) -> B,
    B: Ord, 

Binary searches this sorted slice with a key extraction function.

Assumes that the slice is sorted by the key.

If the value is found then Ok is returned, containing the index of the matching element; if the value is not found then Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See the exponential_search_by documentation for more details.

pub fn contains(&self, x: &T) -> bool where
    T: Ord, 

Returns true if the set contains an element with the given value.

This function uses exponential searching internally because it is verified that the elements are ordered.

use sdset::{Set, Error};

let slice = &[1, 2, 4, 6, 7];
let set = Set::new(slice)?;

assert!(set.contains(&4));

pub fn to_set_buf(&self) -> SetBuf<T> where
    T: Clone, 

Construct the owning version of the Set.

use sdset::{Set, SetBuf, Error};

let set = Set::new(&[1, 2, 4, 6, 7])?;
let setbuf: SetBuf<_> = set.to_set_buf();

pub fn as_slice(&self) -> &[T]

Return the slice "inside" of this Set.

use sdset::{Set, Error};

let slice = &[1, 2, 4, 6, 7];
let set = Set::new(slice)?;

assert_eq!(set.as_slice(), slice);

Trait Implementations

impl<T: PartialOrd> PartialOrd<Set<T>> for Set<T>

fn partial_cmp(&self, other: &Set<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Set<T>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Set<T>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Set<T>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Set<T>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Ord> Ord for Set<T>

fn cmp(&self, other: &Set<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<T: Eq> Eq for Set<T>

impl<T> AsRef<[T]> for Set<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T> AsRef<Set<T>> for Set<T>

fn as_ref(&self) -> &Set<T>

Performs the conversion.

impl<T> AsRef<Set<T>> for SetBuf<T>

fn as_ref(&self) -> &Set<T>

Performs the conversion.

impl<T: PartialEq> PartialEq<Set<T>> for Set<T>

fn eq(&self, other: &Set<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Set<T>) -> bool

This method tests for !=.

impl<T: Debug> Debug for Set<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T> Deref for Set<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Hash> Hash for Set<T>

fn hash<__HT: Hasher>(&self, state: &mut __HT)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].