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 = _

Bad words.

pub const OFFENSIVE: Self = _

Offensive words.

pub const SEXUAL: Self = _

Sexual words.

pub const MEAN: Self = _

Mean words.

pub const EVASIVE: Self = _

Words intended to evade detection.

pub const SPAM: Self = _

Spam/gibberish/SHOUTING.

pub const SAFE: Self = _

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

pub const MILD: Self = _

Not that bad.

pub const MODERATE: Self = _

Bad.

pub const SEVERE: Self = _

Cover your eyes!

pub const MILD_OR_HIGHER: Self = _

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

pub const MODERATE_OR_HIGHER: Self = _

Any level in excess of Type::MILD.

pub const INAPPROPRIATE: Self = _

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

pub const ANY: Self = _

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

pub const NONE: Self = _

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.

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

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

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

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

impl Copy for Type

impl Eq for Type

impl StructuralEq for Type

impl StructuralPartialEq for Type