Trait opcua_server::prelude::status_code::BinaryEncoder

source · [−]

pub trait BinaryEncoder<T> {
    fn byte_len(&self) -> usize;
    fn encode<S>(&self, stream: &mut S) -> Result<usize, StatusCode>
    where
        S: Write;
    fn decode<S>(
        stream: &mut S, 
        decoding_options: &DecodingOptions
    ) -> Result<T, StatusCode>
    where
        S: Read;

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

Expand description

OPC UA Binary Encoding interface. Anything that encodes to binary must implement this. It provides functions to calculate the size in bytes of the struct (for allocating memory), encoding to a stream and decoding from a stream.

Required methods

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.

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<T, 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.

Trait opcua_server::prelude::status_code::BinaryEncoder

Required methods

fn byte_len(&self) -> usize

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

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

Provided methods

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

Implementations on Foreign Types

impl BinaryEncoder<u64> for u64

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<i32> for i32

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<f64> for f64

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<u8> for u8

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<u16> for u16

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<bool> for bool

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<i8> for i8

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<u32> for u32

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<i16> for i16

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<f32> for f32

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<i64> for i64

fn byte_len(&self) -> usize

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

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

Implementors

impl BinaryEncoder<ApplicationType> for ApplicationType

impl BinaryEncoder<AxisScaleEnumeration> for AxisScaleEnumeration

impl BinaryEncoder<BrokerTransportQualityOfService> for BrokerTransportQualityOfService

impl BinaryEncoder<BrowseDirection> for BrowseDirection

impl BinaryEncoder<BrowseResultMask> for BrowseResultMask

impl BinaryEncoder<DataChangeTrigger> for DataChangeTrigger

impl BinaryEncoder<DataSetOrderingType> for DataSetOrderingType

impl BinaryEncoder<DeadbandType> for DeadbandType

impl BinaryEncoder<DiagnosticsLevel> for DiagnosticsLevel

impl BinaryEncoder<ExceptionDeviationFormat> for ExceptionDeviationFormat

impl BinaryEncoder<FilterOperator> for FilterOperator

impl BinaryEncoder<HistoryUpdateType> for HistoryUpdateType

impl BinaryEncoder<IdType> for IdType

impl BinaryEncoder<IdentityCriteriaType> for IdentityCriteriaType

impl BinaryEncoder<MessageSecurityMode> for MessageSecurityMode

impl BinaryEncoder<ModelChangeStructureVerbMask> for ModelChangeStructureVerbMask

impl BinaryEncoder<MonitoringMode> for MonitoringMode

impl BinaryEncoder<NamingRuleType> for NamingRuleType

impl BinaryEncoder<NodeAttributesMask> for NodeAttributesMask

impl BinaryEncoder<NodeClass> for NodeClass

impl BinaryEncoder<NodeIdType> for NodeIdType

impl BinaryEncoder<OpenFileMode> for OpenFileMode

impl BinaryEncoder<OverrideValueHandling> for OverrideValueHandling

impl BinaryEncoder<PerformUpdateType> for PerformUpdateType

impl BinaryEncoder<PubSubDiagnosticsCounterClassification> for PubSubDiagnosticsCounterClassification

impl BinaryEncoder<PubSubState> for PubSubState

impl BinaryEncoder<RedundancySupport> for RedundancySupport

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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