Struct NormalizedRecord 

pub struct NormalizedRecord {
    pub name: String,
    pub unit: Option<String>,
    pub value: Option<f64>,
    pub string_value: Option<String>,
    pub bool_value: Option<bool>,
    pub data_value: Option<Vec<u8>>,
    pub sum: Option<f64>,
    pub time: Option<f64>,
    pub update_time: Option<f64>,
}

A fully resolved SenML record with all base values applied

Fields

name: String

Full resolved name (base name + record name)

unit: Option<String>

Resolved unit (base unit or record unit)

value: Option<f64>

Resolved numeric value (base value + record value)

string_value: Option<String>

String value (unchanged)

bool_value: Option<bool>

Boolean value (unchanged)

data_value: Option<Vec<u8>>

Data value (unchanged)

sum: Option<f64>

Resolved sum (base sum + record sum)

time: Option<f64>

Resolved timestamp (base time + record time)

update_time: Option<f64>

Update time (unchanged)

Implementations

impl NormalizedRecord

pub fn primary_value(&self) -> Option<SenMLValue>

Get the primary value from this record

pub fn has_value(&self) -> bool

Check if this record has any value

pub fn base_name(&self) -> Option<&str>

Get the base name (everything up to last ‘/’)

pub fn local_name(&self) -> &str

Get the local name (everything after last ‘/’)

pub fn validate(&self) -> Result<()>

Validate this normalized record

Trait Implementations

impl Clone for NormalizedRecord

fn clone(&self) -> NormalizedRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalizedRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NormalizedRecord

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NormalizedRecord

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

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 NormalizedRecord