Enum FilterError 

pub enum FilterError {
    SyntaxError {
        position: usize,
        line: usize,
        column: usize,
        message: String,
        suggestion: Option<String>,
    },
    UnexpectedEof {
        position: usize,
        expected: String,
    },
    InvalidChar {
        char: char,
        position: usize,
    },
    UnclosedString {
        position: usize,
    },
    UnclosedParen {
        position: usize,
    },
    InvalidEscape {
        char: char,
        position: usize,
    },
    InvalidNumber {
        value: String,
        position: usize,
    },
    TypeMismatch {
        field: String,
        expected: String,
        actual: String,
    },
    IncompatibleTypes {
        left_type: String,
        right_type: String,
    },
    InvalidOperatorForType {
        operator: String,
        value_type: String,
    },
    UnknownField {
        field: String,
    },
    DivisionByZero,
    NullValue {
        field: String,
    },
    IndexOutOfBounds {
        index: usize,
        length: usize,
    },
    InvalidExpression {
        message: String,
    },
    NestingTooDeep {
        max_depth: usize,
        actual_depth: usize,
    },
    ExpressionTooComplex {
        max_nodes: usize,
        actual_nodes: usize,
    },
    InputTooLong {
        max_length: usize,
        actual_length: usize,
    },
    ArrayTooLarge {
        max_elements: usize,
        actual_elements: usize,
    },
    InvalidStrategy(String),
}

Filter error with position information.

Represents all possible errors that can occur during filter parsing and evaluation. Each error variant includes contextual information to help diagnose and fix the issue.

Error Codes

Error codes follow a structured pattern for easy categorization:

• E001-E099: Syntax errors (parsing)
• E101-E199: Type errors (type checking)
• E201-E299: Evaluation errors (runtime)
• E301-E399: Limit errors (resource constraints)

Example

use edgevec::filter::FilterError;

let error = FilterError::SyntaxError {
    position: 10,
    line: 1,
    column: 11,
    message: "Expected operator".to_string(),
    suggestion: Some("Did you mean '=' instead of ':'?".to_string()),
};

assert_eq!(error.code(), "E001");

Variants

SyntaxError

General syntax error during parsing.

This is the catch-all error for parser failures that don’t fit into more specific categories.

Fields

position: usize

Byte offset in input string where error occurred.

line: usize

1-indexed line number.

column: usize

1-indexed column number.

message: String

Human-readable error message.

suggestion: Option<String>

Optional suggestion for fixing the error.

UnexpectedEof

Unexpected end of input while parsing.

The parser expected more tokens but reached the end of the string.

Fields

position: usize

Byte offset where input ended.

expected: String

Description of what was expected.

InvalidChar

Invalid character encountered during parsing.

The parser found a character that isn’t valid in filter expressions.

Fields

char: char

The invalid character.

position: usize

Byte offset where character was found.

UnclosedString

Unclosed string literal.

A string literal was started but never closed with a matching quote.

Fields

position: usize

Byte offset where string started.

UnclosedParen

Unclosed parenthesis.

An opening parenthesis was found but never closed.

Fields

position: usize

Byte offset where opening paren was found.

InvalidEscape

Invalid escape sequence in string.

An escape sequence like \x was found that isn’t supported.

Fields

char: char

The character after the backslash.

position: usize

Byte offset of the backslash.

InvalidNumber

Invalid number literal.

A number was malformed (e.g., multiple decimal points).

Fields

value: String

The malformed number text.

position: usize

Byte offset where number started.

TypeMismatch

Type mismatch in operation.

An operation was attempted with incompatible types.

Fields

field: String

Name of the field being operated on.

expected: String

Expected type name.

actual: String

Actual type found.

IncompatibleTypes

Incompatible types for comparison.

Two values of incompatible types were compared.

Fields

left_type: String

Type of left operand.

right_type: String

Type of right operand.

InvalidOperatorForType

Invalid operator for type.

An operator was used with a type that doesn’t support it.

Fields

operator: String

The operator that was used.

value_type: String

The type it was used with.

UnknownField

Unknown field reference.

A field was referenced that doesn’t exist in the metadata schema.

Fields

field: String

Name of the unknown field.

DivisionByZero

Division by zero during evaluation.

NullValue

Null value in non-nullable context.

Fields

field: String

Name of the field with null value.

IndexOutOfBounds

Array index out of bounds.

Fields

index: usize

The invalid index.

length: usize

Length of the array.

InvalidExpression

Invalid expression for evaluation.

A literal was used where a boolean expression was expected.

Fields

message: String

Description of what’s wrong with the expression.

NestingTooDeep

Expression nesting too deep.

The filter expression exceeds the maximum allowed nesting depth. This limit prevents stack overflow during evaluation.

Fields

max_depth: usize

Maximum allowed depth.

actual_depth: usize

Actual depth found.

ExpressionTooComplex

Expression too complex.

The filter expression has too many nodes/operations.

Fields

max_nodes: usize

Maximum allowed nodes.

actual_nodes: usize

Actual nodes found.

InputTooLong

Input string too long.

The filter expression string exceeds the maximum allowed length.

Fields

max_length: usize

Maximum allowed length in bytes.

actual_length: usize

Actual length in bytes.

ArrayTooLarge

Array literal too large.

An array literal in the filter has too many elements.

Fields

max_elements: usize

Maximum allowed elements.

actual_elements: usize

Actual elements found.

InvalidStrategy(String)

Invalid filter strategy configuration.

The filter strategy parameters are invalid (e.g., oversample < 1.0).

Implementations

impl FilterError

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

Get the error code for WASM serialization.

Error codes follow a structured pattern:

• E001-E099: Syntax errors
• E101-E199: Type errors
• E201-E299: Evaluation errors
• E301-E399: Limit errors

Example

use edgevec::filter::FilterError;

let error = FilterError::SyntaxError {
    position: 0,
    line: 1,
    column: 1,
    message: "test".to_string(),
    suggestion: None,
};
assert_eq!(error.code(), "E001");

pub fn is_syntax_error(&self) -> bool

Check if this is a syntax error.

pub fn is_type_error(&self) -> bool

Check if this is a type error.

pub fn is_evaluation_error(&self) -> bool

Check if this is an evaluation error.

pub fn is_limit_error(&self) -> bool

Check if this is a limit error.

pub fn position(&self) -> Option<(usize, usize, usize)>

Get the position information if available.

Returns (position, line, column) for errors that have position info.

pub fn suggestion(&self) -> Option<String>

Generate a helpful suggestion based on error type.

Returns a suggestion string that can help the user fix the error.

Trait Implementations

impl Clone for FilterError

fn clone(&self) -> FilterError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FilterError

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

Formats the value using the given formatter.

impl Display for FilterError

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

Formats the value using the given formatter.

impl Error for FilterError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<FilterError> for FilteredSearchError

fn from(e: FilterError) -> Self

Converts to this type from the input type.

impl PartialEq for FilterError

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