Enum Mode

pub enum Mode {
    Manual,
    Random,
    Noise,
    Off,
    Auto,
    Real,
    Altered,
    Protect,
    Empty,
    Software,
    Unknown,
}

Represents different modes for browser fingerprint overrides

This enum is used to control how browser fingerprint are handled and stored in the MySQL database. Each mode determines a specific strategy for managing fingerprint data.

Variants

Manual

Manually specified fingerprint values sent into API

Random

Generates completely random fingerprint values

Noise

Adds random noise to real fingerprint values

Off

Disables fingerprint modifications

Auto

Automatically determines appropriate fingerprint values

Real

Uses real browser fingerprint values without modification

Altered

Altered appropriate fingerprint values, basically like Auto

Protect

Applies privacy-focused modifications to fingerprint (currently used only for Ports)

Empty

Returns empty or null values for fingerprint attributes

Software

Uses software mode instead of hardware mode. Used for videocard and rendering overrides

Unknown

Represents an unrecognized mode value

Trait Implementations

impl Clone for Mode

fn clone(&self) -> Mode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Mode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Mode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromStr for Mode

fn from_str(s: &str) -> Result<Self, Self::Err>

Converts a string to a Mode variant

Arguments

• s - The string to convert

Returns

• Ok(Mode) - The corresponding Mode variant
• Err(Error) - If the string doesn’t match any known mode

Examples

use std::str::FromStr;

let mode = Mode::from_str("real").expect("Valid mode");
assert_eq!(mode, Mode::Real);

let error = Mode::from_str("invalid").unwrap_err();
assert!(matches!(error, Error::UnknownOverrideMode(_)));

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for Mode

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

impl Eq for Mode

impl StructuralPartialEq for Mode