Enum opcua_server::prelude::Variant[−][src]

pub enum Variant {
Show 24 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>),
    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

Guid(Box<Guid, Global>)

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

Array(Box<Array, Global>)

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

Implementations

[src]

impl Variant

[src]

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

Test the flag (convenience method)

[src]

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.

[src]

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

Performs an IMPLICIT conversion from one type to another

[src]

pub fn type_id(&self) -> VariantTypeId

[src]

pub fn is_numeric(&self) -> bool

Tests and returns true if the variant holds a numeric type

[src]

pub fn is_array(&self) -> bool

Test if the variant holds an array

[src]

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

[src]

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.

[src]

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

Converts the numeric type to a double or returns None

[src]

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

[src]

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

[src]

pub fn to_byte_array(&self) -> Variant

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

impl BinaryEncoder<Variant> for Variant

[src]

pub 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

[src]

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

Encodes the instance to the write stream.

[src]

pub 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. Read more

[src]