Struct NegatableSet 

pub struct NegatableSet<I> { /* private fields */ }

Implementations

impl<I: MutableSet + Default> NegatableSet<I>

pub fn constant(value: bool) -> Self

pub fn empty() -> Self

pub fn all() -> Self

impl<I: MutableSet> NegatableSet<I>

pub fn is_empty(&self) -> bool

pub fn is_all(&self) -> bool

pub fn into_elements(self) -> I

pub fn elements(&self) -> &I

pub fn elements_mut(&mut self) -> &mut I

impl<I: MutableSet> NegatableSet<I>

pub fn contains(&self, value: &I::Item) -> bool

pub fn insert(&mut self, that: I::Item)

pub fn is_superset(&self, that: &Self) -> bool

pub fn is_subset(&self, that: &Self) -> bool

pub fn is_disjoint(&self, that: &Self) -> bool

impl<I: MutableSet> NegatableSet<I>

where I::Item: Ord + Clone,

pub fn remove(&mut self, that: &I::Item)

Trait Implementations

impl<'a, I: MutableSet + 'a> BitAnd for &'a NegatableSet<I>

where &'a I: BitAnd<Output = I> + BitOr<Output = I> + Sub<Output = I>,

type Output = NegatableSet<I>

The resulting type after applying the & operator.

fn bitand(self, that: Self) -> Self::Output

Performs the & operation.

impl<I> BitAndAssign for NegatableSet<I>

where I: BitAndAssign + BitOrAssign + SubAssign + MutableSet,

fn bitand_assign(&mut self, that: Self)

Performs the &= operation.

impl<'a, I: MutableSet> BitOr for &'a NegatableSet<I>

where &'a I: BitAnd<Output = I> + BitOr<Output = I> + Sub<Output = I>,

type Output = NegatableSet<I>

The resulting type after applying the | operator.

fn bitor(self, that: Self) -> Self::Output

Performs the | operation.

impl<I> BitOrAssign for NegatableSet<I>

where I: BitAndAssign + BitOrAssign + SubAssign + MutableSet,

fn bitor_assign(&mut self, that: Self)

Performs the |= operation.

impl<'a, I: MutableSet> BitXor for &'a NegatableSet<I>

where &'a I: BitXor<Output = I>,

type Output = NegatableSet<I>

The resulting type after applying the ^ operator.

fn bitxor(self, that: Self) -> Self::Output

Performs the ^ operation.

impl<I> BitXorAssign for NegatableSet<I>

where I: BitXorAssign + MutableSet,

fn bitxor_assign(&mut self, that: Self)

Performs the ^= operation.

impl<I: Clone> Clone for NegatableSet<I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: MutableSet> Debug for NegatableSet<I>

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

Formats the value using the given formatter.

impl<I: Default> Default for NegatableSet<I>

fn default() -> NegatableSet<I>

Returns the “default value” for a type.

impl<'de, A> Deserialize<'de> for NegatableSet<A>

where A: MutableSet + Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<I: MutableSet> From<I> for NegatableSet<I>

fn from(value: I) -> Self

Converts to this type from the input type.

impl<I: MutableSet + Default> From<bool> for NegatableSet<I>

fn from(value: bool) -> Self

Converts to this type from the input type.

impl<I: Hash> Hash for NegatableSet<I>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, I: MutableSet + Clone> Not for &'a NegatableSet<I>

type Output = NegatableSet<I>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<I: MutableSet + Clone> Not for NegatableSet<I>

type Output = NegatableSet<I>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<I: PartialEq> PartialEq for NegatableSet<I>

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<A> Serialize for NegatableSet<A>

where A: MutableSet + Serialize,

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

Serialize this value into the given Serde serializer.

impl<'a, I: MutableSet> Sub for &'a NegatableSet<I>

where &'a I: BitAnd<Output = I> + BitOr<Output = I> + Sub<Output = I>,

type Output = NegatableSet<I>

The resulting type after applying the - operator.

fn sub(self, that: Self) -> Self::Output

Performs the - operation.

impl<I> SubAssign for NegatableSet<I>

where I: BitAndAssign + BitOrAssign + SubAssign + MutableSet,

fn sub_assign(&mut self, that: Self)

Performs the -= operation.

impl<I: Eq> Eq for NegatableSet<I>