Trait opcua_server::prelude::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_limits: &DecodingLimits
    ) -> Result<T, StatusCode>
    where
        S: Read;

    fn to_vec(&self) -> Vec<u8, Global> ⓘ { ... }
}

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 byte length of the structure. This calculation should be exact and as efficient as possible.

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_limits: &DecodingLimits
) -> Result<T, 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.

Trait opcua_server::prelude::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_limits: &DecodingLimits) -> Result<T, StatusCode>where S: Read,

Provided Methods§

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

Implementations on Foreign Types§

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, _: &DecodingLimits) -> Result<u8, 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, _: &DecodingLimits) -> Result<i8, 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, _: &DecodingLimits) -> Result<i32, 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, _: &DecodingLimits) -> Result<u16, 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, _: &DecodingLimits) -> Result<f32, 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, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> Result<i16, 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, _: &DecodingLimits) -> Result<i64, 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, _: &DecodingLimits) -> Result<bool, 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, _: &DecodingLimits) -> Result<f64, StatusCode>where S: Read,

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, _: &DecodingLimits) -> Result<u64, StatusCode>where S: Read,

Implementors§

impl BinaryEncoder<MessageSecurityMode> for MessageSecurityMode

impl BinaryEncoder<MonitoringMode> for MonitoringMode

impl BinaryEncoder<SecurityHeader> for SecurityHeader

impl BinaryEncoder<SupportedMessage> for SupportedMessage

impl BinaryEncoder<Variant> for Variant

impl BinaryEncoder<ApplicationType> for ApplicationType

impl BinaryEncoder<BrowseDirection> for BrowseDirection

impl BinaryEncoder<DataChangeTrigger> for DataChangeTrigger

impl BinaryEncoder<FilterOperator> for FilterOperator

impl BinaryEncoder<NodeClass> for NodeClass

impl BinaryEncoder<SecurityTokenRequestType> for SecurityTokenRequestType

impl BinaryEncoder<ServerState> for ServerState

impl BinaryEncoder<TimestampsToReturn> for TimestampsToReturn

impl BinaryEncoder<UserTokenType> for UserTokenType

impl BinaryEncoder<Argument> for opcua_server::prelude::argument::Argument

impl BinaryEncoder<ActivateSessionRequest> for ActivateSessionRequest

impl BinaryEncoder<ActivateSessionResponse> for ActivateSessionResponse

impl BinaryEncoder<AddNodesItem> for AddNodesItem

impl BinaryEncoder<AddNodesRequest> for AddNodesRequest

impl BinaryEncoder<AddNodesResponse> for AddNodesResponse

impl BinaryEncoder<AddNodesResult> for AddNodesResult

impl BinaryEncoder<AddReferencesItem> for AddReferencesItem

impl BinaryEncoder<AddReferencesRequest> for AddReferencesRequest

impl BinaryEncoder<AddReferencesResponse> for AddReferencesResponse

impl BinaryEncoder<AggregateConfiguration> for AggregateConfiguration

impl BinaryEncoder<AggregateFilter> for AggregateFilter

impl BinaryEncoder<AggregateFilterResult> for AggregateFilterResult

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

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

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

fn decode<S>(stream: &mut S, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> Result<i64, StatusCode>where
S: Read,

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

fn decode<S>(stream: &mut S, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> 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, _: &DecodingLimits) -> Result<u64, StatusCode>where
S: Read,