Enum Datum 

#[non_exhaustive]
pub enum Datum {
    Null,
    Boolean(bool),
    Unsigned(u64),
    Signed(i64),
    Real(f32),
    Double(f64),
    NonFinite {
        float: String,
    },
    Text(String),
    Octets {
        octets: String,
    },
    Enumerated {
        value: u32,
        name: Option<String>,
    },
    Bits {
        bits: String,
        names: Option<Vec<String>>,
    },
    Date {
        date: String,
    },
    Time {
        time: String,
    },
    Object {
        object_type: String,
        type_number: u32,
        instance: u32,
    },
    List(Vec<Datum>),
    Constructed {
        element: String,
        text: String,
        fields: Option<Fields>,
    },
    Raw {
        raw: String,
    },
}

A property value as typed data. Serialized untagged, so each form is told apart by its JSON type and keys.

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.

Null

NULL, as null.

Boolean(bool)

A BOOLEAN, as true or false.

Unsigned(u64)

An Unsigned, as a number.

Signed(i64)

A Signed, as a number.

Real(f32)

A REAL, as a number.

Double(f64)

A Double, as a number.

NonFinite

A REAL or Double that is not a number or infinite, which JSON numbers can’t hold: {"float": "NaN"}.

Fields

float: String

NaN, inf or -inf.

Text(String)

A CharacterString, as a string.

Octets

An OCTET STRING: {"octets": "0a0b"}, lowercase hex.

Fields

octets: String

The octets as hex.

Enumerated

An ENUMERATED: {"value": 2, "name": "offnormal"}, without a name when the property’s enumeration isn’t known.

Fields

value: u32

The number on the wire.

name: Option<String>

Its name in kebab case.

Bits

A BIT STRING: {"bits": "0100", "names": ["fault"]}, first bit first. names lists the set bits by name, and is left out when the property’s bits have no names.

Fields

bits: String

One digit a bit.

names: Option<Vec<String>>

The set bits’ names in kebab case.

Date

A Date: {"date": "2026-10-19"}, in the text’s form.

Fields

date: String

The date as the text writes it.

Time

A Time: {"time": "07:00"}, in the text’s form.

Fields

time: String

The time as the text writes it.

Object

A BACnetObjectIdentifier: {"type": "analog-input", "type_number": 0, "instance": 1}.

Fields

object_type: String

The object type in kebab case.

type_number: u32

The object type’s number.

instance: u32

The instance number.

List(Vec<Datum>)

Several values, or the elements of a list or array, as an array.

Constructed

One constructed element (a timestamp, a schedule day, a recipient): {"element": "daily-schedule", "text": "Mon 07:00 = active"}. The element names its kind; the text is for display, not for parsing. An element decoded field by field (an Event_Parameters value, an event notification’s values) adds them under fields.

Fields

element: String

The element’s kind in kebab case, destination.

text: String

The element as the text writes it.

fields: Option<Fields>

Its fields by name, when the element is decoded field by field.

Raw

Octets that don’t decode: {"raw": "0e0f"}.

Fields

raw: String

The octets as hex.

Implementations

impl Datum

pub fn may_hold_device_text(&self) -> bool

Whether its text may quote a character string a device wrote: a string, or a constructed element whose kind isn’t in PLAIN_ELEMENTS or whose fields may. A front end shows such text as data, never as its own words.

Trait Implementations

impl Clone for Datum

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Datum

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

Formats the value using the given formatter.

impl PartialEq for Datum

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Datum

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 Datum