Struct adblock::BlockerResult

pub struct BlockerResult {
    pub matched: bool,
    pub explicit_cancel: bool,
    pub important: bool,
    pub redirect: Option<String>,
    pub exception: Option<String>,
    pub filter: Option<String>,
    pub error: Option<String>,
}

The result of an ad-blocking check.

Fields

matched: bool

explicit_cancel: bool

Normally, Brave Browser returns 200 OK with an empty body when matched is True, except if explicit_cancel is also True, in which case the request is cancelled.

important: bool

Important is used to signal that a rule with the important option matched. An important match means that exceptions should not apply and no further checking is neccesary--the request should be blocked (empty body or cancelled).

Brave Browser keeps seperate instances of Blocker for default lists and regional ones, so important here is used to correct behaviour between them: checking should stop instead of moving to the next instance iff an important rule matched.

redirect: Option<String>

Iff the blocker matches a rule which has the redirect option, as per uBlock Origin's redirect syntax, the redirect is not None. The redirect field contains the body of the redirect to be injected.

exception: Option<String>

Exception is not None when the blocker matched on an exception rule. Effectively this means that there was a match, but the request should not be blocked. It is a non-empty string if the blocker was initialized from a list of rules with debugging enabled, otherwise the original string representation is discarded to reduce memory use.

filter: Option<String>

Filter--similarly to exception--includes the string representation of the rule when there is a match and debugging is enabled. Otherwise, on a match, it is not None.

error: Option<String>

The error field is only used to signal that there was an error in parsing the provided URLs when using the simpler check_network_urls method.

Trait Implementations

impl<'a> ExtractExt<'a> for &'a BlockerResult

type Target = PyRef<'a, BlockerResult>

impl<'a> ExtractExt<'a> for &'a mut BlockerResult

type Target = PyRefMut<'a, BlockerResult>

impl HasMethodsInventory for BlockerResult

type Methods = Pyo3MethodsInventoryForBlockerResult

impl HasProtoRegistry for BlockerResult

fn registry() -> &'static PyProtoRegistry

impl Into<BlockerResult> for RustBlockerResult

fn into(self) -> BlockerResult

Performs the conversion.

impl IntoPy<PyObject> for BlockerResult

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PyClass for BlockerResult

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it's PyDict.

impl PyClassAlloc for BlockerResult

unsafe fn new(py: Python<'_>, subtype: *mut PyTypeObject) -> *mut Self::Layout

Allocate the actual field for #[pyclass].

unsafe fn dealloc(py: Python<'_>, self_: *mut Self::Layout)

Deallocate #[pyclass] on the Python heap.

impl PyClassSend for BlockerResult

type ThreadChecker = ThreadCheckerStub<BlockerResult>

impl<'p> PyObjectProtocol<'p> for BlockerResult

fn __repr__(&'p self) -> <BlockerResult as PyObjectReprProtocol<'p>>::Result

fn __getattr__(&'p self, name: Self::Name) -> Self::Result where
    Self: PyObjectGetAttrProtocol<'p>, 

fn __setattr__(
    &'p mut self,
    name: Self::Name,
    value: Self::Value
) -> Self::Result where
    Self: PyObjectSetAttrProtocol<'p>, 

fn __delattr__(&'p mut self, name: Self::Name) -> Self::Result where
    Self: PyObjectDelAttrProtocol<'p>, 

fn __str__(&'p self) -> Self::Result where
    Self: PyObjectStrProtocol<'p>, 

fn __format__(&'p self, format_spec: Self::Format) -> Self::Result where
    Self: PyObjectFormatProtocol<'p>, 

fn __hash__(&'p self) -> Self::Result where
    Self: PyObjectHashProtocol<'p>, 

fn __bytes__(&'p self) -> Self::Result where
    Self: PyObjectBytesProtocol<'p>, 

fn __richcmp__(&'p self, other: Self::Other, op: CompareOp) -> Self::Result where
    Self: PyObjectRichcmpProtocol<'p>, 

fn __bool__(&'p self) -> Self::Result where
    Self: PyObjectBoolProtocol<'p>, 

impl<'p> PyObjectReprProtocol<'p> for BlockerResult

type Result = PyResult<String>

impl PyTypeInfo for BlockerResult

type Type = BlockerResult

Type of objects to store in PyObject struct

type BaseType = PyAny

Base class

type Layout = PyCell<Self>

Layout

type BaseLayout = PyCellBase<PyAny>

Layout of Basetype.

type Initializer = PyClassInitializer<Self>

Initializer for layout

type AsRefTarget = PyCell<Self>

Utility type to make AsPyRef work

const NAME: &'static str

Class name

const MODULE: Option<&'static str>

Module name, if any

const DESCRIPTION: &'static str

Class doc string

const FLAGS: usize

Type flags (ie PY_TYPE_FLAG_GC, PY_TYPE_FLAG_WEAKREF)

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

PyTypeObject instance for this type.

fn is_instance(object: &PyAny) -> bool

Check if *mut ffi::PyObject is instance of this type

fn is_exact_instance(object: &PyAny) -> bool

Check if *mut ffi::PyObject is exact instance of this type