Enum EvalexprError 

#[non_exhaustive]
pub enum EvalexprError<NumericTypes: EvalexprNumericTypes = DefaultNumericTypes> {
    WrongOperatorArgumentAmount {
        expected: usize,
        actual: usize,
    },
    WrongFunctionArgumentAmount {
        expected: RangeInclusive<usize>,
        actual: usize,
    },
    ExpectedString {
        actual: Value<NumericTypes>,
    },
    ExpectedInt {
        actual: Value<NumericTypes>,
    },
    ExpectedFloat {
        actual: Value<NumericTypes>,
    },
    ExpectedNumber {
        actual: Value<NumericTypes>,
    },
    ExpectedNumberOrString {
        actual: Value<NumericTypes>,
    },
    ExpectedBoolean {
        actual: Value<NumericTypes>,
    },
    ExpectedTuple {
        actual: Value<NumericTypes>,
    },
    ExpectedFixedLengthTuple {
        expected_length: usize,
        actual: Value<NumericTypes>,
    },
    ExpectedRangedLengthTuple {
        expected_length: RangeInclusive<usize>,
        actual: Value<NumericTypes>,
    },
    ExpectedEmpty {
        actual: Value<NumericTypes>,
    },
    AppendedToLeafNode,
    PrecedenceViolation,
    VariableIdentifierNotFound(String),
    FunctionIdentifierNotFound(String),
    TypeError {
        expected: Vec<ValueType>,
        actual: Value<NumericTypes>,
    },
    WrongTypeCombination {
        operator: Operator<NumericTypes>,
        actual: Vec<ValueType>,
    },
    UnmatchedLBrace,
    UnmatchedRBrace,
    UnmatchedDoubleQuote,
    MissingOperatorOutsideOfBrace,
    UnmatchedPartialToken {
        first: PartialToken<NumericTypes>,
        second: Option<PartialToken<NumericTypes>>,
    },
    AdditionError {
        augend: Value<NumericTypes>,
        addend: Value<NumericTypes>,
    },
    SubtractionError {
        minuend: Value<NumericTypes>,
        subtrahend: Value<NumericTypes>,
    },
    NegationError {
        argument: Value<NumericTypes>,
    },
    MultiplicationError {
        multiplicand: Value<NumericTypes>,
        multiplier: Value<NumericTypes>,
    },
    DivisionError {
        dividend: Value<NumericTypes>,
        divisor: Value<NumericTypes>,
    },
    ModulationError {
        dividend: Value<NumericTypes>,
        divisor: Value<NumericTypes>,
    },
    InvalidRegex {
        regex: String,
        message: String,
    },
    ContextNotMutable,
    IllegalEscapeSequence(String),
    BuiltinFunctionsCannotBeEnabled,
    BuiltinFunctionsCannotBeDisabled,
    OutOfBoundsAccess,
    IntFromUsize {
        usize_int: usize,
    },
    IntIntoUsize {
        int: NumericTypes::Int,
    },
    RandNotEnabled,
    CustomMessage(String),
}

Errors used in this crate.

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.

WrongOperatorArgumentAmount

An operator was called with a wrong amount of arguments.

Fields

expected: usize

The expected amount of arguments.

actual: usize

The actual amount of arguments.

WrongFunctionArgumentAmount

A function was called with a wrong amount of arguments.

Fields

expected: RangeInclusive<usize>

The expected amount of arguments.

actual: usize

The actual amount of arguments.

ExpectedString

A string value was expected.

Fields

actual: Value<NumericTypes>

The actual value.

ExpectedInt

An integer value was expected.

Fields

actual: Value<NumericTypes>

The actual value.

ExpectedFloat

A float value was expected.

Fields

actual: Value<NumericTypes>

The actual value.

ExpectedNumber

A numeric value was expected. Numeric values are the variants Value::Int and Value::Float.

Fields

actual: Value<NumericTypes>

The actual value.

ExpectedNumberOrString

A numeric or string value was expected. Numeric values are the variants Value::Int and Value::Float.

Fields

actual: Value<NumericTypes>

The actual value.

ExpectedBoolean

A boolean value was expected.

Fields

actual: Value<NumericTypes>

The actual value.

ExpectedTuple

A tuple value was expected.

Fields

actual: Value<NumericTypes>

The actual value.

ExpectedFixedLengthTuple

A tuple value of a certain length was expected.

Fields

expected_length: usize

The expected length.

actual: Value<NumericTypes>

The actual value.

ExpectedRangedLengthTuple

A tuple value of a certain length range was expected.

Fields

expected_length: RangeInclusive<usize>

The expected length range.

actual: Value<NumericTypes>

The actual value.

ExpectedEmpty

An empty value was expected.

Fields

actual: Value<NumericTypes>

The actual value.

AppendedToLeafNode

Tried to append a child to a leaf node. Leaf nodes cannot have children.

PrecedenceViolation

Tried to append a child to a node such that the precedence of the child is not higher. This error should never occur. If it does, please file a bug report.

VariableIdentifierNotFound(String)

A VariableIdentifier operation did not find its value in the context.

FunctionIdentifierNotFound(String)

A FunctionIdentifier operation did not find its value in the context.

TypeError

A value has the wrong type. Only use this if there is no other error that describes the expected and provided types in more detail.

Fields

expected: Vec<ValueType>

The expected types.

actual: Value<NumericTypes>

The actual value.

WrongTypeCombination

An operator is used with a wrong combination of types.

Fields

operator: Operator<NumericTypes>

The operator that whose evaluation caused the error.

actual: Vec<ValueType>

The types that were used in the operator causing it to fail.

UnmatchedLBrace

An opening brace without a matching closing brace was found.

UnmatchedRBrace

A closing brace without a matching opening brace was found.

UnmatchedDoubleQuote

A double quote without a matching second double quote was found.

MissingOperatorOutsideOfBrace

Left of an opening brace or right of a closing brace is a token that does not expect the brace next to it. For example, writing 4(5) would yield this error, as the 4 does not have any operands.

UnmatchedPartialToken

A PartialToken is unmatched, such that it cannot be combined into a full Token. This happens if for example a single = is found, surrounded by whitespace. It is not a token, but it is part of the string representation of some tokens.

Fields

first: PartialToken<NumericTypes>

The unmatched partial token.

second: Option<PartialToken<NumericTypes>>

The token that follows the unmatched partial token and that cannot be matched to the partial token, or None, if first is the last partial token in the stream.

AdditionError

An addition operation performed by Rust failed.

Fields

augend: Value<NumericTypes>

The first argument of the addition.

addend: Value<NumericTypes>

The second argument of the addition.

SubtractionError

A subtraction operation performed by Rust failed.

Fields

minuend: Value<NumericTypes>

The first argument of the subtraction.

subtrahend: Value<NumericTypes>

The second argument of the subtraction.

NegationError

A negation operation performed by Rust failed.

Fields

argument: Value<NumericTypes>

The argument of the negation.

MultiplicationError

A multiplication operation performed by Rust failed.

Fields

multiplicand: Value<NumericTypes>

The first argument of the multiplication.

multiplier: Value<NumericTypes>

The second argument of the multiplication.

DivisionError

A division operation performed by Rust failed.

Fields

dividend: Value<NumericTypes>

The first argument of the division.

divisor: Value<NumericTypes>

The second argument of the division.

ModulationError

A modulation operation performed by Rust failed.

Fields

dividend: Value<NumericTypes>

The first argument of the modulation.

divisor: Value<NumericTypes>

The second argument of the modulation.

InvalidRegex

A regular expression could not be parsed

Fields

regex: String

The invalid regular expression

message: String

Failure message from the regex engine

ContextNotMutable

A modification was attempted on a Context that does not allow modifications.

IllegalEscapeSequence(String)

An escape sequence within a string literal is illegal.

BuiltinFunctionsCannotBeEnabled

This context does not allow enabling builtin functions.

BuiltinFunctionsCannotBeDisabled

This context does not allow disabling builtin functions.

OutOfBoundsAccess

Out of bounds sequence access.

IntFromUsize

A usize was attempted to be converted to an int, but it was out of range.

Fields

usize_int: usize

The usize that was attempted to be converted.

IntIntoUsize

An int was attempted to be converted to a usize, but it was out of range.

Fields

int: NumericTypes::Int

The int that was attempted to be converted.

RandNotEnabled

The feature rand is not enabled, but required for the used function.

CustomMessage(String)

A custom error explained by its message.

Implementations

impl<NumericTypes: EvalexprNumericTypes> EvalexprError<NumericTypes>

pub fn wrong_operator_argument_amount(actual: usize, expected: usize) -> Self

Construct a WrongOperatorArgumentAmount error.

pub fn wrong_function_argument_amount(actual: usize, expected: usize) -> Self

Construct a WrongFunctionArgumentAmount error for a function with a fixed amount of arguments.

pub fn wrong_function_argument_amount_range( actual: usize, expected: RangeInclusive<usize>, ) -> Self

Construct a WrongFunctionArgumentAmount error for a function with a range of possible amounts of arguments.

pub fn type_error(actual: Value<NumericTypes>, expected: Vec<ValueType>) -> Self

Constructs EvalexprError::TypeError{actual, expected}.

pub fn wrong_type_combination( operator: Operator<NumericTypes>, actual: Vec<ValueType>, ) -> Self

Constructs EvalexprError::WrongTypeCombination{operator, actual}.

pub fn expected_string(actual: Value<NumericTypes>) -> Self

Constructs EvalexprError::ExpectedString{actual}.

pub fn expected_int(actual: Value<NumericTypes>) -> Self

Constructs EvalexprError::ExpectedInt{actual}.

pub fn expected_float(actual: Value<NumericTypes>) -> Self

Constructs EvalexprError::ExpectedFloat{actual}.

pub fn expected_number(actual: Value<NumericTypes>) -> Self

Constructs EvalexprError::ExpectedNumber{actual}.

pub fn expected_number_or_string(actual: Value<NumericTypes>) -> Self

Constructs EvalexprError::ExpectedNumberOrString{actual}.

pub fn expected_boolean(actual: Value<NumericTypes>) -> Self

Constructs EvalexprError::ExpectedBoolean{actual}.

pub fn expected_tuple(actual: Value<NumericTypes>) -> Self

Constructs EvalexprError::ExpectedTuple{actual}.

pub fn expected_fixed_len_tuple( expected_len: usize, actual: Value<NumericTypes>, ) -> Self

Constructs EvalexprError::ExpectedFixedLenTuple{expected_len, actual}.

pub fn expected_ranged_len_tuple( expected_len: RangeInclusive<usize>, actual: Value<NumericTypes>, ) -> Self

Constructs EvalexprError::ExpectedFixedLenTuple{expected_len, actual}.

pub fn expected_empty(actual: Value<NumericTypes>) -> Self

Constructs EvalexprError::ExpectedEmpty{actual}.

pub fn invalid_regex(regex: String, message: String) -> Self

Constructs EvalexprError::InvalidRegex(regex)

Trait Implementations

impl<NumericTypes: Clone + EvalexprNumericTypes> Clone for EvalexprError<NumericTypes>

where NumericTypes::Int: Clone,

fn clone(&self) -> EvalexprError<NumericTypes>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<NumericTypes: Debug + EvalexprNumericTypes> Debug for EvalexprError<NumericTypes>

where NumericTypes::Int: Debug,

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

Formats the value using the given formatter.

impl<NumericTypes: EvalexprNumericTypes> Display for EvalexprError<NumericTypes>

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

Formats the value using the given formatter.

impl<NumericTypes: EvalexprNumericTypes> Error for EvalexprError<NumericTypes>

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<NumericTypes: PartialEq + EvalexprNumericTypes> PartialEq for EvalexprError<NumericTypes>

where NumericTypes::Int: PartialEq,

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