Struct rustrict::Type

pub struct Type(_);

Type is represents a type or severity of inappropriateness. They can be combined with bitwise AND and OR operators, and are not mutually exclusive.

For example, the following means profane or at-least moderately mean: Type::PROFANE | (Type::MEAN & Type::MODERATE_OR_HIGHER)

Implementations

impl Type

pub const PROFANE: Self = Self(TypeRepr::PROFANE)

Bad words.

pub const OFFENSIVE: Self = Self(TypeRepr::OFFENSIVE)

Offensive words.

pub const SEXUAL: Self = Self(TypeRepr::SEXUAL)

Sexual words.

pub const MEAN: Self = Self(TypeRepr::MEAN)

Mean words.

pub const EVASIVE: Self = Self(TypeRepr::EVASIVE)

Words intended to evade detection.

pub const SPAM: Self = Self(TypeRepr::SPAM)

Spam/gibberish/SHOUTING.

pub const SAFE: Self = Self(TypeRepr::SAFE)

One of a very small number of safe phases. Recommended to enforce this on users who repeatedly evade the filter.

pub const MILD: Self = Self(TypeRepr::MILD)

Not that bad.

pub const MODERATE: Self = Self(TypeRepr::MODERATE)

Bad.

pub const SEVERE: Self = Self(TypeRepr::SEVERE)

Cover your eyes!

pub const MILD_OR_HIGHER: Self = Self(TypeRepr::MILD_OR_HIGHER)

Any level; Type::MILD, Type::MODERATE, or Type::SEVERE.

pub const MODERATE_OR_HIGHER: Self = Self(TypeRepr::MODERATE_OR_HIGHER)

Any level in excess of Type::MILD.

pub const INAPPROPRIATE: Self = Self(TypeRepr::INAPPROPRIATE)

The default Type, meaning profane, offensive, sexual, or severely mean.

pub const ANY: Self = Self(TypeRepr::ANY)

Any type of detection (except SAFE). This will be expanded to cover all future types.

pub const NONE: Self = Self(TypeRepr::NONE)

No type of detection.

pub fn is(self, threshold: Self) -> bool

Returns true if and only if self, the analysis result, meets the given threshold.

pub fn isnt(self, threshold: Self) -> bool

Logical opposite of Self::is.

pub fn empty() -> Self

👎 Deprecated:

this is for backwards-compatibility, use Type::NONE instead

pub fn is_empty(self) -> bool

👎 Deprecated:

this is for backwards-compatibility, compare with Type::NONE instead

pub fn bits(self) -> u32

👎 Deprecated:

this is for backwards-compatibility, there is no replacement

Trait Implementations

impl BitAnd<Type> for Type

type Output = Type

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign<Type> for Type

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<Type> for Type

type Output = Type

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<Type> for Type

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Type

Note: Can’t impl directly on TypeRepr due to https://github.com/bitflags/bitflags/issues/218

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

Formats the value using the given formatter.

impl Default for Type

fn default() -> Self

Returns a reasonable default for censoring or blocking.

impl Hash for Type

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 Not for Type

type Output = Type

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq<Type> for Type

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

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

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

This method tests for !=.

impl Copy for Type

impl Eq for Type

impl StructuralEq for Type

impl StructuralPartialEq for Type