Enum Variant 

pub enum Variant {
    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>),
    Guid(Box<Guid>),
    StatusCode(StatusCode),
    ByteString(ByteString),
    XmlElement(XmlElement),
    QualifiedName(Box<QualifiedName>),
    LocalizedText(Box<LocalizedText>),
    NodeId(Box<NodeId>),
    ExpandedNodeId(Box<ExpandedNodeId>),
    ExtensionObject(ExtensionObject),
    Variant(Box<Variant>),
    DataValue(Box<DataValue>),
    DiagnosticInfo(Box<DiagnosticInfo>),
    Array(Box<Array>),
}

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>)

DateTime

Guid(Box<Guid>)

Guid

StatusCode(StatusCode)

StatusCode

ByteString(ByteString)

ByteString

XmlElement(XmlElement)

XmlElement

QualifiedName(Box<QualifiedName>)

QualifiedName

LocalizedText(Box<LocalizedText>)

LocalizedText

NodeId(Box<NodeId>)

NodeId

ExpandedNodeId(Box<ExpandedNodeId>)

ExpandedNodeId

ExtensionObject(ExtensionObject)

ExtensionObject

Variant(Box<Variant>)

Variant containing a nested variant.

DataValue(Box<DataValue>)

DataValue

DiagnosticInfo(Box<DiagnosticInfo>)

DiagnosticInfo

Array(Box<Array>)

Single dimension array which can contain any scalar type, all the same type. Nested arrays will be rejected. To represent matrices or nested arrays, set the array_dimensions field on the Array.

Implementations

impl Variant

pub fn serialize_variant_value( &self, stream: &mut JsonStreamWriter<&mut dyn Write>, ctx: &Context<'_>, ) -> EncodingResult<()>

JSON serialize the value of a variant using OPC-UA JSON encoding.

Note that this serializes just the value. To include the type ID, use JsonEncodable::encode.

impl Variant

pub fn get_variant_default(ty: VariantScalarTypeId) -> Variant

Get a default variant of the given type.

pub fn xml_decode_variant_value( stream: &mut XmlStreamReader<&mut dyn Read>, context: &Context<'_>, key: &str, ) -> EncodingResult<Self>

Decode an XML variant value from stream, consuming the rest of the current element.

impl Variant

pub fn value_byte_len(&self, ctx: &Context<'_>) -> usize

Get the value in bytes of the contents of this variant if it is serialize to OPC-UA binary.

To get the full byte length including type ID, use BinaryEncodable::encode

pub fn encode_value<S: Write + ?Sized>( &self, stream: &mut S, ctx: &Context<'_>, ) -> EncodingResult<()>

Encode the value of this variant as binary to the given stream.

Note that to encode a full variant with type ID and other details, use BinaryEncodable::encode

impl Variant

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

Test the flag (convenience method)

pub fn cast<'a>(&self, target_type: impl Into<VariantTypeId<'a>>) -> 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.

pub fn convert<'a>(&self, target_type: impl Into<VariantTypeId<'a>>) -> Variant

Performs an IMPLICIT conversion from one type to another

pub fn type_id(&self) -> VariantTypeId<'_>

Get the type ID of this variant. This can be useful to work with the variant abstractly, and check if the variant is of the expected type and dimensions.

pub fn scalar_type_id(&self) -> Option<VariantScalarTypeId>

Get the scalar type id of this variant, if present.

This returns None only if the variant is empty.

pub fn is_empty(&self) -> bool

Returns true if this variant is Variant::Empty.

pub fn is_numeric(&self) -> bool

Tests and returns true if the variant holds a numeric type

pub fn is_array(&self) -> bool

Test if the variant holds an array

pub fn as_array(&self) -> Option<&Vec<Variant>>

Try to get the inner array if this is an array variant.

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

Check if this is an array of the given variant type.

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.

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

Converts the numeric type to a double or returns None

pub fn data_type(&self) -> Option<ExpandedNodeId>

Returns the scalar data type. Returns None if the variant is Empty.

pub fn to_byte_array(&self) -> Result<Self, ArrayError>

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

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

Set a range of values in this variant using a different variant.

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

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

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.

pub fn try_cast_to<T: TryFromVariant>(self) -> Result<T, Error>

Try to cast this variant to the type T.

impl Variant

pub fn from_nodeset( val: &XmlVariant, ctx: &Context<'_>, ) -> EncodingResult<Variant>

Create a Variant value from a NodeSet2 variant object. Note that this is different from the FromXml implementation of Variant, which accepts an untyped XML node.

Trait Implementations

impl BinaryDecodable for Variant

fn decode<S: Read + ?Sized>( stream: &mut S, ctx: &Context<'_>, ) -> EncodingResult<Self>

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.

impl BinaryEncodable for Variant

fn byte_len(&self, ctx: &Context<'_>) -> 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.

fn encode<S: Write + ?Sized>( &self, stream: &mut S, ctx: &Context<'_>, ) -> EncodingResult<()>

Encodes the instance to the write stream.

fn override_encoding(&self) -> Option<BuiltInDataEncoding>

Override the extension object encoding used for this type. This only makes sense if the type can only ever be encoded using a single built-in encoding.

fn encode_to_vec(&self, ctx: &Context<'_>) -> Vec<u8>

Convenience method for encoding a message straight into an array of bytes. It is preferable to reuse buffers than to call this so it should be reserved for tests and trivial code.

impl Clone for Variant

fn clone(&self) -> Variant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Variant

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

Formats the value using the given formatter.

impl Default for Variant

fn default() -> Variant

Returns the “default value” for a type.

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.

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

Formats the value using the given formatter.

impl EventField for Variant

fn get_value( &self, attribute_id: AttributeId, index_range: &NumericRange, remaining_path: &[QualifiedName], ) -> Variant

Get the variant representation of this field, using the given index range.

impl<'a, T> From<&'a [T]> for Variant

where T: Into<Variant> + VariantType + Clone,

fn from(value: &'a [T]) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a Vec<T>> for Variant

where T: Into<Variant> + VariantType + Clone,

fn from(value: &'a Vec<T>) -> Self

Converts to this type from the input type.

impl From<()> for Variant

fn from(_: ()) -> Self

Converts to this type from the input type.

impl<'a, 'b> From<(VariantScalarTypeId, &'a [&'b str])> for Variant

fn from(v: (VariantScalarTypeId, &'a [&'b str])) -> Self

Converts to this type from the input type.

impl<T: Into<Variant>> From<(VariantScalarTypeId, Vec<T>)> for Variant

fn from(v: (VariantScalarTypeId, Vec<T>)) -> Self

Converts to this type from the input type.

impl<T: Into<Variant>> From<(VariantScalarTypeId, Vec<T>, Vec<u32>)> for Variant

fn from(v: (VariantScalarTypeId, Vec<T>, Vec<u32>)) -> Self

Converts to this type from the input type.

impl From<DataTypeDefinition> for Variant

fn from(value: DataTypeDefinition) -> Self

Converts to this type from the input type.

impl<T> From<Option<T>> for Variant

where T: Into<Variant>,

fn from(value: Option<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for Variant

where T: IntoVariant,

fn from(value: T) -> Self

Converts to this type from the input type.

impl From<Variant> for DataValue

fn from(v: Variant) -> Self

Converts to this type from the input type.

impl From<Variant> for LiteralOperand

fn from(v: Variant) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for Variant

where T: Into<Variant> + VariantType,

fn from(value: Vec<T>) -> Self

Converts to this type from the input type.

impl JsonDecodable for Variant

fn decode( stream: &mut JsonStreamReader<&mut dyn Read>, ctx: &Context<'_>, ) -> EncodingResult<Self>

Decode Self from a JSON stream.

impl JsonEncodable for Variant

fn encode( &self, stream: &mut JsonStreamWriter<&mut dyn Write>, ctx: &Context<'_>, ) -> EncodingResult<()>

Write the type to the provided JSON writer.

impl PartialEq for Variant

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

fn try_from_variant(v: Variant) -> Result<Self, Error>

Try to cast the given variant to this type.

impl UaNullable for Variant

fn is_ua_null(&self) -> bool

Return true if this value is null, meaning it can be left out when being encoded in JSON and XML encodings.

impl VariantType for Variant

fn variant_type_id() -> VariantScalarTypeId

The variant kind this type will be represented as.

impl XmlDecodable for Variant

fn decode( stream: &mut XmlStreamReader<&mut dyn Read>, context: &Context<'_>, ) -> Result<Self, Error>

Decode a value from an XML stream.

impl XmlEncodable for Variant

fn encode( &self, stream: &mut XmlStreamWriter<&mut dyn Write>, ctx: &Context<'_>, ) -> EncodingResult<()>

Encode a value to an XML stream.

impl XmlType for Variant

const TAG: &'static str = "Variant"

The static fallback tag for this type. Convenience feature, but also used in nested types.

fn tag(&self) -> &str

The XML tag name for this type.

impl StructuralPartialEq for Variant