Enum Zaehlergroesse 

#[non_exhaustive]
pub enum Zaehlergroesse {
    G2Komma5,
    G4,
    G6,
    G10,
    G16,
    G25,
    G40,
    G65,
    G100,
    G160,
    G250,
    G400,
    G650,
    G1000,
    G1600,
    G2500,
    G4000,
    G6500,
    G10000,
    G12500,
    G16000,
    Unknown,
}

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

Auflistung möglicher Größen von Zählern

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.

G2Komma5

G4

G6

G10

G16

G25

G40

G65

G100

G160

G250

G400

G650

G1000

G1600

G2500

G4000

G6500

G10000

G12500

G16000

Unknown

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

Implementations

impl Zaehlergroesse

pub const VARIANTS: &'static [Self]

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

Excludes the forward-compatibility Zaehlergroesse::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 Zaehlergroesse::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 Zaehlergroesse.

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

Example

// Never yields the `Unknown` catch-all, so the count matches `COUNT`.
assert_eq!(Zaehlergroesse::iter_known().count(), Zaehlergroesse::COUNT);
assert!(Zaehlergroesse::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.

Zaehlergroesse::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 Zaehlergroesse::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!(Zaehlergroesse::from_wire("G2KOMMA5"), Ok(Zaehlergroesse::G2Komma5));
// Out-of-schema values are rejected rather than degraded:
assert!(Zaehlergroesse::from_wire("NOT_A_REAL_VALUE").is_err());
// …including the `Unknown` catch-all's own wire spelling:
assert!(Zaehlergroesse::from_wire("UNKNOWN").is_err());

pub const fn is_unknown(&self) -> bool

Returns true if this value is the forward-compatibility Zaehlergroesse::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 Zaehlergroesse

fn as_ref(&self) -> &str

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

impl Bo4eEnum for Zaehlergroesse

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 Zaehlergroesse

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 Zaehlergroesse

fn clone(&self) -> Zaehlergroesse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for Zaehlergroesse

Available on crate feature utoipa only.

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

impl Copy for Zaehlergroesse

impl Debug for Zaehlergroesse

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

Formats the value using the given formatter.

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

Available on crate feature sqlx only.

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

Use Zaehlergroesse::from_wire on a String column, or check Zaehlergroesse::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 Zaehlergroesse

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 Zaehlergroesse

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

Formats the value using the given formatter.

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

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 Zaehlergroesse

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

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

Converts to this type from the input type.

impl From<Zaehlergroesse> for &'static str

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

Converts to this type from the input type.

impl FromStr for Zaehlergroesse

Available on crate feature strum only.

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl Hash for Zaehlergroesse

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 Zaehlergroesse

Available on crate feature strum only.

type Iterator = ZaehlergroesseIter

fn iter() -> ZaehlergroesseIter

impl JsonSchema for Zaehlergroesse

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 Zaehlergroesse

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

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Zaehlergroesse

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

Available on crate feature sqlx only.

Lets Vec<Zaehlergroesse> 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 Zaehlergroesse

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 Zaehlergroesse

impl ToSchema for Zaehlergroesse

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 Zaehlergroesse

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<Zaehlergroesse, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl Type<Postgres> for Zaehlergroesse

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.