Enum opcua_server::prelude::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(DateTime),
    Guid(Guid),
    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>),
    DataValue(Box<DataValue, Global>),
    Array(Vec<Variant, Global>),
    MultiDimensionArray(Box<MultiDimensionArray, Global>),
}

A Variant holds all other OPC UA 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

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

DateTime

Guid(Guid)

Guid

StatusCode(StatusCode)

StatusCode

ByteString(ByteString)

ByteString

XmlElement(UAString)

XmlElement

QualifiedName(Box<QualifiedName, Global>)

QualifiedName

LocalizedText(Box<LocalizedText, Global>)

LocalizedText

NodeId(Box<NodeId, Global>)

NodeId

ExpandedNodeId(Box<ExpandedNodeId, Global>)

ExpandedNodeId

ExtensionObject(Box<ExtensionObject, Global>)

ExtensionObject

DataValue(Box<DataValue, Global>)

DataValue (boxed because a DataValue itself holds a Variant)

Array(Vec<Variant, Global>)

Single dimension array A variant can be an array of other kinds (all of which must be the same type), second argument is the dimensions of the array which should match the array length, otherwise BadDecodingError

MultiDimensionArray(Box<MultiDimensionArray, Global>)

Multi dimension array A variant can be an array of other kinds (all of which must be the same type), second argument is the dimensions of the array which should match the array length, otherwise BadDecodingError Higher rank dimensions are serialized first. For example an array with dimensions [2,2,2] is written in this order: [0,0,0], [0,0,1], [0,1,0], [0,1,1], [1,0,0], [1,0,1], [1,1,0], [1,1,1]

Implementations

impl Variant

pub fn new<T>(value: T) -> Variantwhere
    T: 'static + Into<Variant>,

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

Test the flag (convenience method)

pub fn type_id(&self) -> VariantTypeId

pub fn new_multi_dimension_array(
    values: Vec<Variant, Global>,
    dimensions: Vec<i32, Global>
) -> Variant

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 is_numeric_array(&self) -> bool

Tests and returns true if the variant is an array containing numeric values

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 from_i32_array(in_values: &[i32]) -> Variant

pub fn from_u32_array(in_values: &[u32]) -> Variant

pub fn from_string_array(in_values: &[String]) -> Variant

pub fn into_u32_array(&self) -> Result<Vec<u32, Global>, StatusCode>

Returns an array of UInt32s

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

Trait Implementations

impl BinaryEncoder<Variant> for Variant

fn byte_len(&self) -> usize

Returns the byte length of the structure. This calculation should be exact and as efficient as possible.

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

Encodes the instance to the write stream.

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

Decodes an instance from the read stream. The decoding limits are 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.

fn to_vec(&self) -> Vec<u8, Global>

impl Clone for Variant

fn clone(&self) -> Variant

Returns a copy 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<(), Error>

Formats the value using the given formatter.

impl Default for Variant

fn default() -> Variant

Returns the “default value” for a type.

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

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

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a str> for Variant

fn from(value: &'a str) -> Variant

Converts to this type from the input type.

impl From<ByteString> for Variant

fn from(v: ByteString) -> Variant

Converts to this type from the input type.

impl From<DataValue> for Variant

fn from(v: DataValue) -> Variant

Converts to this type from the input type.

impl From<DateTime> for Variant

fn from(v: DateTime) -> Variant

Converts to this type from the input type.

impl From<ExpandedNodeId> for Variant

fn from(v: ExpandedNodeId) -> Variant

Converts to this type from the input type.

impl From<ExtensionObject> for Variant

fn from(v: ExtensionObject) -> Variant

Converts to this type from the input type.

impl From<Guid> for Variant

fn from(v: Guid) -> Variant

Converts to this type from the input type.

impl From<LocalizedText> for Variant

fn from(v: LocalizedText) -> Variant

Converts to this type from the input type.

impl From<MultiDimensionArray> for Variant

fn from(v: MultiDimensionArray) -> Variant

Converts to this type from the input type.

impl From<NodeId> for Variant

fn from(v: NodeId) -> Variant

Converts to this type from the input type.

impl From<QualifiedName> for Variant

fn from(v: QualifiedName) -> Variant

Converts to this type from the input type.

impl From<StatusCode> for Variant

fn from(v: StatusCode) -> Variant

Converts to this type from the input type.

impl From<String> for Variant

fn from(value: String) -> Variant

Converts to this type from the input type.

impl From<UAString> for Variant

fn from(v: UAString) -> Variant

Converts to this type from the input type.

impl From<Variant> for DataValue

fn from(v: Variant) -> DataValue

Converts to this type from the input type.

impl From<Vec<Variant, Global>> for Variant

fn from(v: Vec<Variant, Global>) -> Variant

Converts to this type from the input type.

impl From<Vec<u32, Global>> for Variant

fn from(v: Vec<u32, Global>) -> Variant

Converts to this type from the input type.

impl From<bool> for Variant

fn from(v: bool) -> Variant

Converts to this type from the input type.

impl From<f32> for Variant

fn from(v: f32) -> Variant

Converts to this type from the input type.

impl From<f64> for Variant

fn from(v: f64) -> Variant

Converts to this type from the input type.

impl From<i16> for Variant

fn from(v: i16) -> Variant

Converts to this type from the input type.

impl From<i32> for Variant

fn from(v: i32) -> Variant

Converts to this type from the input type.

impl From<i64> for Variant

fn from(v: i64) -> Variant

Converts to this type from the input type.

impl From<i8> for Variant

fn from(v: i8) -> Variant

Converts to this type from the input type.

impl From<u16> for Variant

fn from(v: u16) -> Variant

Converts to this type from the input type.

impl From<u32> for Variant

fn from(v: u32) -> Variant

Converts to this type from the input type.

impl From<u64> for Variant

fn from(v: u64) -> Variant

Converts to this type from the input type.

impl From<u8> for Variant

fn from(v: u8) -> Variant

Converts to this type from the input type.

impl PartialEq<Variant> for Variant

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Variant

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToString 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 to_string(&self) -> String

Converts the given value to a String.

impl StructuralPartialEq for Variant