Enum rustrict::BlockReason

#[non_exhaustive]
pub enum BlockReason {
    Inappropriate(Type),
    Unsafe {
        remaining: Duration,
        targeted: bool,
    },
    Repetitious(usize),
    Spam(Duration),
    Muted(Duration),
    Empty,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Inappropriate(Type)

The particular message was severely inappropriate, more specifically, Type.

Unsafe

Fields

remaining: Duration

targeted: bool

Whether unsafe mode was targeted at this user (as opposed to configured globally).

Recent messages were generally inappropriate, and this message isn’t on the safe list. Alternatively, if targeted is false, safe mode was configured globally. Try again after Duration.

Repetitious(usize)

This message was too similar to usize recent messages.

Spam(Duration)

Too many messages per unit time, try again after Duration.

Muted(Duration)

Manually muted for Duration.

Empty

Message was, at least after censoring, completely empty.

Implementations

impl BlockReason

pub fn generic_str(self) -> &'static str

You may display BlockReason in any manner you choose, but this will return a reasonable default warning to send to the user.

Examples found in repository

src/context.rs (line 563)

    pub fn contextual_string(self) -> String {
        match self {
            Self::Inappropriate(typ) => String::from(if typ.is(Type::OFFENSIVE) {
                "Your message was held for being highly offensive"
            } else if typ.is(Type::SEXUAL) {
                "Your message was held for being overly sexual"
            } else if typ.is(Type::MEAN) {
                "Your message was held for being overly mean"
            } else {
                "Your message was held for severe profanity"
            }),
            Self::Unsafe {
                remaining,
                targeted: true,
            } => format!(
                "You have been restricted for {} due to profanity/spam",
                FormattedDuration(remaining)
            ),
            Self::Unsafe {
                remaining,
                targeted: false,
            } => format!("Safe mode is active for {}", FormattedDuration(remaining)),
            Self::Repetitious(count) => {
                format!("Your message was too similar to {} recent messages", count)
            }
            Self::Spam(dur) => format!(
                "You have been muted for {} due to excessive frequency",
                FormattedDuration(dur)
            ),
            Self::Muted(dur) => format!("You have been muted for {}", FormattedDuration(dur)),
            _ => String::from(self.generic_str()),
        }
    }

pub fn contextual_str(self) -> String

👎Deprecated: use contextual_string

pub fn contextual_string(self) -> String

You may display BlockReason in any manner you choose, but this will return a reasonable default warning to send to the user that includes some context (such as how long they are muted for).

Examples found in repository

src/context.rs (line 527)

    pub fn contextual_str(self) -> String {
        self.contextual_string()
    }

Trait Implementations

impl Clone for BlockReason

fn clone(&self) -> BlockReason

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BlockReason

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

Formats the value using the given formatter.

impl PartialEq<BlockReason> for BlockReason

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

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

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 BlockReason

impl StructuralPartialEq for BlockReason