Struct negatable_set::NegatableSet

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

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<&'a NegatableSet<I>> for &'a NegatableSet<I> where
    &'a I: BitAnd<Output = I>,
    &'a I: BitOr<Output = I>,
    &'a 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: MutableSet> BitAndAssign<NegatableSet<I>> for NegatableSet<I> where
    I: BitAndAssign,
    I: BitOrAssign,
    I: SubAssign, 

fn bitand_assign(&mut self, that: Self)

Performs the &= operation.

impl<'a, I: MutableSet> BitOr<&'a NegatableSet<I>> for &'a NegatableSet<I> where
    &'a I: BitAnd<Output = I>,
    &'a I: BitOr<Output = I>,
    &'a 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: MutableSet> BitOrAssign<NegatableSet<I>> for NegatableSet<I> where
    I: BitAndAssign,
    I: BitOrAssign,
    I: SubAssign, 

fn bitor_assign(&mut self, that: Self)

Performs the |= operation.

impl<'a, I: MutableSet> BitXor<&'a NegatableSet<I>> 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: MutableSet> BitXorAssign<NegatableSet<I>> for NegatableSet<I> where
    I: BitXorAssign, 

fn bitxor_assign(&mut self, that: Self)

Performs the ^= operation.

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

fn clone(&self) -> Self

Returns a copy 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: Eq> Eq for NegatableSet<I>

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

fn from(value: I) -> Self

Performs the conversion.

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

fn from(value: bool) -> Self

Performs the conversion.

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, 

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<NegatableSet<I>> for NegatableSet<I>

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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<&'a NegatableSet<I>> for &'a NegatableSet<I> where
    &'a I: BitAnd<Output = I>,
    &'a I: BitOr<Output = I>,
    &'a 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: MutableSet> SubAssign<NegatableSet<I>> for NegatableSet<I> where
    I: BitAndAssign,
    I: BitOrAssign,
    I: SubAssign, 

fn sub_assign(&mut self, that: Self)

Performs the -= operation.