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);

pub fn iter(&self) -> Iter<T>

Returns an iterator over this ordered set.

use sdset::Set;

let x = Set::new_unchecked(&[1, 2, 4]);
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);

Trait Implementations

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> Borrow<Set<T>> for SetBuf<T>

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

Immutably borrows from an owned value.

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

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

Formats the value using the given formatter.

impl<'_, T> Default for &'_ Set<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T> Deref for Set<T>

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

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

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

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

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].

impl<'a, T> IntoIterator for &'a Set<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

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

This method returns an [Ordering] between self and other.

#[must_use] fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use] fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use] fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

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: 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> StructuralEq for Set<T>

impl<T> StructuralPartialEq for Set<T>

impl<T: Clone> ToOwned for Set<T>

type Owned = SetBuf<T>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning.