Struct Type

pub struct Type(/* private fields */);

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. (low severity and/or low confidence)

pub const MODERATE: Self

Bad. (moderate severity and/or moderate confidence)

pub const SEVERE: Self

Cover your eyes! (high severity and/or high confidence)

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

Inappropriate for general audiences (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 for Type

type Output = Type

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign for Type

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr for Type

type Output = Type

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign 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

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

fn eq(&self, other: &Type) -> 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 Copy for Type

impl Eq for Type

impl StructuralPartialEq for Type