Struct Set 

pub struct Set<T: Debug> {
    pub set: HashSet<T>,
    pub if_none: bool,
}

Allows semantics similar to a HashSet<Option<String>> without having to convert Option<&str>s to Option<String>s.

Serializes and deserializes identically to HashSet<Option<String>>, though it’s not yet optimized.

Examples

use serde_json::from_str;
use url_cleaner_engine::types::*;

assert_eq!(serde_json::from_str::<Set<String>>(r#"["abc"]"#      ).unwrap(), Set {set: ["abc".into()].into(), if_none: false});
assert_eq!(serde_json::from_str::<Set<String>>(r#"["abc", null]"#).unwrap(), Set {set: ["abc".into()].into(), if_none: true });

Fields

set: HashSet<T>

The set of T.

if_none: bool

If true, act like None is in Self::set.

Implementations

impl<T: Debug + Hash + Eq> Set<T>

pub fn with_capacity(capacity: usize) -> Self

HashSet::with_capacity.

pub fn contains<Q>(&self, value: Option<&Q>) -> bool

where T: Borrow<Q>, Q: Debug + Hash + Eq + ?Sized,

HashSet::contains.

Examples

use url_cleaner_engine::types::*;

let no_none = Set {set: ["abc"].into(), if_none: false};
assert!( no_none.contains(Some("abc")));
assert!(!no_none.contains(None::<&str>));

let yes_none = Set {set: ["abc"].into(), if_none: true};
assert!(yes_none.contains(Some("abc")));
assert!(yes_none.contains(None::<&str>));

pub fn insert(&mut self, value: Option<T>) -> bool

HashSet::insert.

pub fn extend<I: IntoIterator<Item = Option<T>>>(&mut self, iter: I)

HashSet::insert.

pub fn remove<Q>(&mut self, value: Option<&Q>) -> bool

where T: Borrow<Q>, Q: Debug + Hash + Eq + ?Sized,

HashSet::remove.

Trait Implementations

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

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

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

Implemented manually to avoid the T: Default bound.

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Debug + Deserialize<'de> + Eq + Hash> Deserialize<'de> for Set<T>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T: Debug + Eq + Hash, const N: usize> From<[Option<T>; N]> for Set<T>

fn from(value: [Option<T>; N]) -> Self

Converts to this type from the input type.

impl<T: Debug + Eq + Hash, const N: usize> From<[T; N]> for Set<T>

fn from(value: [T; N]) -> Self

Converts to this type from the input type.

impl<T: Debug + Hash + Eq> From<HashSet<Option<T>>> for Set<T>

fn from(value: HashSet<Option<T>>) -> Self

Converts to this type from the input type.

impl<T: Debug + Hash + Eq> From<Set<T>> for HashSet<Option<T>>

fn from(value: Set<T>) -> Self

Converts to this type from the input type.

impl<T: Debug + Eq + Hash> FromIterator<Option<T>> for Set<T>

fn from_iter<I: IntoIterator<Item = Option<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Debug + Eq + Hash> FromIterator<T> for Set<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Debug + Hash + Eq> PartialEq for Set<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T: Debug + Hash + Eq> Eq for Set<T>