Enum opcua_core::prelude::Variant

source · [−]

pub enum Variant {
Show 27 variants    Empty,
    Boolean(bool),
    SByte(i8),
    Byte(u8),
    Int16(i16),
    UInt16(u16),
    Int32(i32),
    UInt32(u32),
    Int64(i64),
    UInt64(u64),
    Float(f32),
    Double(f64),
    String(UAString),
    DateTime(Box<DateTime, Global>),
    Guid(Box<Guid, Global>),
    StatusCode(StatusCode),
    ByteString(ByteString),
    XmlElement(UAString),
    QualifiedName(Box<QualifiedName, Global>),
    LocalizedText(Box<LocalizedText, Global>),
    NodeId(Box<NodeId, Global>),
    ExpandedNodeId(Box<ExpandedNodeId, Global>),
    ExtensionObject(Box<ExtensionObject, Global>),
    Variant(Box<Variant, Global>),
    DataValue(Box<DataValue, Global>),
    Diagnostics(Box<DiagnosticInfo, Global>),
    Array(Box<Array, Global>),
}

Expand description

A Variant holds built-in OPC UA data types, including single and multi dimensional arrays, data values and extension objects.

As variants may be passed around a lot on the stack, Boxes are used for more complex types to keep the size of this type down a bit, especially when used in arrays.

Variants

`Empty`

Empty type has no value. It is equivalent to a Null value (part 6 5.1.6)

`Boolean(bool)`

Boolean

`SByte(i8)`

Signed byte

`Byte(u8)`

Unsigned byte

`Int16(i16)`

Signed 16-bit int

`UInt16(u16)`

Unsigned 16-bit int

`Int32(i32)`

Signed 32-bit int

`UInt32(u32)`

Unsigned 32-bit int

`Int64(i64)`

Signed 64-bit int

`UInt64(u64)`

Unsigned 64-bit int

`Float(f32)`

Float

`Double(f64)`

Double

`String(UAString)`

String

`DateTime(Box<DateTime, Global>)`

DateTime

`StatusCode(StatusCode)`

StatusCode

`ByteString(ByteString)`

ByteString

`XmlElement(UAString)`

XmlElement

`QualifiedName(Box<QualifiedName, Global>)`

QualifiedName

`LocalizedText(Box<LocalizedText, Global>)`

LocalizedText

`ExpandedNodeId(Box<ExpandedNodeId, Global>)`

ExpandedNodeId

`ExtensionObject(Box<ExtensionObject, Global>)`

ExtensionObject

`Variant(Box<Variant, Global>)`

`DataValue(Box<DataValue, Global>)`

`Diagnostics(Box<DiagnosticInfo, Global>)`

`Array(Box<Array, Global>)`

Single dimension array which can contain any scalar type, all the same type. Nested arrays will be rejected.

Implementations

source

impl Variant

source

pub fn test_encoding_flag(encoding_mask: u8, flag: u8) -> bool

Test the flag (convenience method)

source

pub fn cast(&self, target_type: VariantTypeId) -> Variant

Performs an EXPLICIT cast from one type to another. This will first attempt an implicit conversion and only then attempt to cast. Casting is potentially lossy.

source

pub fn convert(&self, target_type: VariantTypeId) -> Variant

Performs an IMPLICIT conversion from one type to another

source

pub fn type_id(&self) -> VariantTypeId

source

pub fn is_numeric(&self) -> bool

Tests and returns true if the variant holds a numeric type

source

pub fn is_array(&self) -> bool

Test if the variant holds an array

source

pub fn is_array_of_type(&self, variant_type: VariantTypeId) -> bool

source

pub fn is_valid(&self) -> bool

Tests that the variant is in a valid state. In particular for arrays ensuring that the values are all acceptable and for a multi dimensional array that the dimensions equal the actual values.

source

pub fn as_f64(&self) -> Option<f64>

Converts the numeric type to a double or returns None

source

pub fn array_data_type(&self) -> Option<NodeId>

source

pub fn scalar_data_type(&self) -> Option<NodeId>

source

pub fn to_byte_array(&self) -> Result<Variant, StatusCode>

This function is for a special edge case of converting a byte string to a single array of bytes

source

pub fn eq_scalar_type(&self, other: &Variant) -> bool

source

pub fn eq_array_type(&self, other: &Variant) -> bool

source

pub fn set_range_of(
 &mut self,
 range: NumericRange,
 other: &Variant
) -> Result<(), StatusCode>

source

pub fn range_of(&self, range: NumericRange) -> Result<Variant, StatusCode>

This function gets a range of values from the variant if it is an array, or returns a clone of the variant itself.

Trait Implementations

source

impl BinaryEncoder<Variant> for Variant

source

fn byte_len(&self) -> usize

Returns the exact byte length of the structure as it would be if encode were called. This may be called prior to writing to ensure the correct amount of space is available. Read more

source

fn encode<S>(&self, stream: &mut S) -> Result<usize, StatusCode> where
S: Write,

Encodes the instance to the write stream.

source

fn decode<S>(
 stream: &mut S,
 decoding_options: &DecodingOptions
) -> Result<Variant, StatusCode> where
 S: Read,

Decodes an instance from the read stream. The decoding options contains restrictions set by the server / client on the length of strings, arrays etc. If these limits are exceeded the implementation should return with a BadDecodingError as soon as possible. Read more

source

fn encode_to_vec(&self) -> Vec<u8, Global>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where A: Allocator,`

source

impl Clone for Variant

source

fn clone(&self) -> Variant

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

source

impl Debug for Variant

source

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

Formats the value using the given formatter. Read more

source

impl Default for Variant

source

fn default() -> Variant

Returns the “default value” for a type. Read more

source

impl<'de> Deserialize<'de> for Variant

source

fn deserialize<D>(
deserializer: D
) -> Result<Variant, <D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

source

impl Display for Variant

This implementation is mainly for debugging / convenience purposes, to eliminate some of the noise in common types from using the Debug trait.

source

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

Formats the value using the given formatter. Read more

source