Enum Operator 

#[non_exhaustive]
pub enum Operator {
    Addition,
    Subtraktion,
    Multiplikation,
    Division,
    Unknown,
}

Available on crate feature versioned and (crate features json or versioned) only.

Mit dieser Aufzählung können Operationen festgelegt werden.

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.

Addition

Subtraktion

Multiplikation

Division

Unknown

Unknown or future variant — produced when deserializing a value that is not yet known to this version of the library.

Implementations

impl Operator

pub const VARIANTS: &'static [Self]

All variants defined by the BO4E schema, in declaration order.

Excludes the forward-compatibility Operator::Unknown catch-all, so this is exactly the set of values that appear on the wire. Available without the strum feature — use it to drift-guard SQL CHECK lists and mappings.

pub const COUNT: usize

Number of schema-defined variants (equal to VARIANTS.len()), excluding the Operator::Unknown catch-all. Stable for this schema version.

pub fn iter_known() -> impl Iterator<Item = Self> + Clone

Returns an iterator over all known variants of Operator.

Yields only variants that correspond to values defined in the BO4E schema (i.e. Self::VARIANTS), never the Operator::Unknown catch-all. Available without the strum feature.

Example

// Never yields the `Unknown` catch-all, so the count matches `COUNT`.
assert_eq!(Operator::iter_known().count(), Operator::COUNT);
assert!(Operator::iter_known().all(|v| v.is_known()));

pub const fn as_wire(&self) -> &'static str

Returns the canonical BO4E wire string (SCREAMING_SNAKE_CASE) for this value.

Operator::Unknown renders as "UNKNOWN", matching its serialized form.

pub fn from_wire(s: &str) -> Result<Self, UnknownVariant>

Strictly parses a BO4E wire string into a known variant.

Unlike the lenient serde / FromStr path — which maps any unrecognized value (a typo, a legacy code, or a value from a newer schema) to Operator::Unknown — this returns Err for values not defined in this schema version, including the literal "UNKNOWN". Use it at the ingest boundary to reject bad values instead of silently degrading them.

Example

assert_eq!(Operator::from_wire("ADDITION"), Ok(Operator::Addition));
// Out-of-schema values are rejected rather than degraded:
assert!(Operator::from_wire("NOT_A_REAL_VALUE").is_err());
// …including the `Unknown` catch-all's own wire spelling:
assert!(Operator::from_wire("UNKNOWN").is_err());

pub const fn is_unknown(&self) -> bool

Returns true if this value is the forward-compatibility Operator::Unknown catch-all (an out-of-schema value).

pub const fn is_known(&self) -> bool

Returns true if this value is a known, schema-defined variant.

Trait Implementations

impl AsRef<str> for Operator

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Bo4eEnum for Operator

const VARIANTS: &'static [Self] = Self::VARIANTS

All variants defined by the BO4E schema, in declaration order.

const COUNT: usize = Self::COUNT

Number of schema-defined variants (equal to VARIANTS.len()), excluding the Unknown catch-all. Stable for a given schema version — use it to drift-guard hand-maintained variant counts.

fn as_wire(&self) -> &'static str

Returns the canonical BO4E wire string (SCREAMING_SNAKE_CASE) for this value.

fn from_wire(s: &str) -> Result<Self, UnknownVariant>

Strictly parses a BO4E wire string, returning Err for any value not defined in this schema version — including the literal "UNKNOWN".

fn is_unknown(&self) -> bool

Returns true if this value is the forward-compatibility Unknown catch-all — i.e. an out-of-schema value produced by a lenient decode.

fn is_known(&self) -> bool

Returns true if this value is a known, schema-defined variant.

impl Bo4eStrict for Operator

fn collect_unknown_enums(&self, path: &str, out: &mut Vec<String>)

Appends, to out, the field_path-formatted location of every enum field in self (recursively) that holds the forward-compatibility Unknown catch-all. path is the JSON-path of self relative to the root of the check ("" at the top level).

fn unknown_enum_paths(&self) -> Vec<String>

Returns the JSON-paths of every enum field (recursively) that decoded to Unknown. Empty when the value is fully in-schema.

fn ensure_known_enums(&self) -> Result<(), StrictError>

Returns Err(StrictError) listing every out-of-schema (Unknown) enum value in self, or Ok(()) if there are none. Call this after a lenient serde decode to reject payloads that carry typos, legacy codes, or values from a newer schema.

impl Clone for Operator

fn clone(&self) -> Operator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for Operator

Available on crate feature utoipa only.

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Copy for Operator

impl Debug for Operator

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

Formats the value using the given formatter.

impl<'r> Decode<'r, Postgres> for Operator

Available on crate feature sqlx only.

Decodes leniently, matching the serde path: a value the schema does not define becomes Operator::Unknown rather than a decode error, so a database row written by a newer schema version still reads back.

Use Operator::from_wire on a String column, or check Operator::is_known, where out-of-schema values must be rejected.

fn decode( value: <Postgres as Database>::ValueRef<'r>, ) -> Result<Self, BoxDynError>

Decode a new value of this type using a raw value from the database.

impl<'de> Deserialize<'de> for Operator

Available on crate feature serde only.

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Operator

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

Formats the value using the given formatter.

impl<'q> Encode<'q, Postgres> for Operator

Available on crate feature sqlx only.

Encodes as the canonical BO4E wire string, borrowed from as_wire — no intermediate String or serde_json::Value is allocated.

fn encode_by_ref( &self, buf: &mut <Postgres as Database>::ArgumentBuffer<'q>, ) -> Result<IsNull, BoxDynError>

Writes the value of self into buf without moving self.

fn encode( self, buf: &mut <DB as Database>::ArgumentBuffer<'q>, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>

where Self: Sized,

Writes the value of self into buf in the expected format for the database.

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

fn size_hint(&self) -> usize

impl Eq for Operator

impl<'_derivative_strum> From<&'_derivative_strum Operator> for &'static str

fn from(x: &'_derivative_strum Operator) -> &'static str

Converts to this type from the input type.

impl From<Operator> for &'static str

fn from(x: Operator) -> &'static str

Converts to this type from the input type.

impl FromStr for Operator

Available on crate feature strum only.

type Err = ParseError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for Operator

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoEnumIterator for Operator

Available on crate feature strum only.

type Iterator = OperatorIter

fn iter() -> OperatorIter

impl JsonSchema for Operator

Available on crate feature schemars only.

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ord for Operator

fn cmp(&self, other: &Operator) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for Operator

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Operator

fn partial_cmp(&self, other: &Operator) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PgHasArrayType for Operator

Available on crate feature sqlx only.

Lets Vec<Operator> bind to a TEXT[] column. Only this crate can provide it: the trait and the enum are both foreign to any consumer, so the orphan rule rules out a downstream impl.

fn array_type_info() -> PgTypeInfo

fn array_compatible(ty: &PgTypeInfo) -> bool

impl Serialize for Operator

Available on crate feature serde only.

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Operator

impl ToSchema for Operator

Available on crate feature utoipa only.

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.

impl TryFrom<&str> for Operator

Available on crate feature strum only.

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Operator, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl Type<Postgres> for Operator

Available on crate feature sqlx only.

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type.

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type.