Trait opcua_server::prelude::BinaryEncoder

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 encode_to_vec(&self) -> Vec<u8> { ... }
}

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

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.

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

Loading content...

Provided methods

fn encode_to_vec(&self) -> Vec<u8>

Loading content...

Implementations on Foreign Types

impl BinaryEncoder<u8> for u8

An unsigned byt integer value between 0 and 255.

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<f64> for f64

An IEEE double precision (64 bit) floating point value.

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

An unsigned integer value between 0 and 18446744073709551615.

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, 

impl BinaryEncoder<u32> for u32

An unsigned integer value between 0 and 4294967295.

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<u16> for u16

An unsigned integer value between 0 and 65535.

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<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<f32> for f32

An IEEE single precision (32 bit) floating point value.

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<i16> for i16

A signed integer value between −32768 and 32767.

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<i32> for i32

A signed integer value between −2147483648 and 2147483647.

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<i64> for i64

A signed integer value between −9223372036854775808 and 9223372036854775807.

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, 

Loading content...

Implementors

impl BinaryEncoder<AccessLevelExType> for AccessLevelExType

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<AccessLevelExType, StatusCode> where
    S: Read, 

impl BinaryEncoder<AccessLevelType> for AccessLevelType

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<AccessLevelType, StatusCode> where
    S: Read, 

impl BinaryEncoder<AccessRestrictionType> for AccessRestrictionType

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<AccessRestrictionType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ApplicationType> for ApplicationType

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<ApplicationType, StatusCode> where
    S: Read, 

impl BinaryEncoder<AttributeWriteMask> for AttributeWriteMask

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<AttributeWriteMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<AxisScaleEnumeration> for AxisScaleEnumeration

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<AxisScaleEnumeration, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrokerTransportQualityOfService> for BrokerTransportQualityOfService

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<BrokerTransportQualityOfService, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowseDirection> for BrowseDirection

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<BrowseDirection, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowseResultMask> for BrowseResultMask

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<BrowseResultMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataChangeTrigger> for DataChangeTrigger

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<DataChangeTrigger, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetFieldContentMask> for DataSetFieldContentMask

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<DataSetFieldContentMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetFieldFlags> for DataSetFieldFlags

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<DataSetFieldFlags, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetOrderingType> for DataSetOrderingType

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<DataSetOrderingType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeadbandType> for DeadbandType

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<DeadbandType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DiagnosticsLevel> for DiagnosticsLevel

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<DiagnosticsLevel, StatusCode> where
    S: Read, 

impl BinaryEncoder<EventNotifierType> for EventNotifierType

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<EventNotifierType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ExceptionDeviationFormat> for ExceptionDeviationFormat

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<ExceptionDeviationFormat, StatusCode> where
    S: Read, 

impl BinaryEncoder<FilterOperator> for FilterOperator

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<FilterOperator, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryUpdateType> for HistoryUpdateType

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<HistoryUpdateType, StatusCode> where
    S: Read, 

impl BinaryEncoder<IdType> for IdType

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<IdType, StatusCode> where
    S: Read, 

impl BinaryEncoder<IdentityCriteriaType> for IdentityCriteriaType

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<IdentityCriteriaType, StatusCode> where
    S: Read, 

impl BinaryEncoder<JsonDataSetMessageContentMask> for JsonDataSetMessageContentMask

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<JsonDataSetMessageContentMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<JsonNetworkMessageContentMask> for JsonNetworkMessageContentMask

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<JsonNetworkMessageContentMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<MessageSecurityMode> for MessageSecurityMode

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<MessageSecurityMode, StatusCode> where
    S: Read, 

impl BinaryEncoder<ModelChangeStructureVerbMask> for ModelChangeStructureVerbMask

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<ModelChangeStructureVerbMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoringMode> for MonitoringMode

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<MonitoringMode, StatusCode> where
    S: Read, 

impl BinaryEncoder<NamingRuleType> for NamingRuleType

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<NamingRuleType, StatusCode> where
    S: Read, 

impl BinaryEncoder<NodeAttributesMask> for NodeAttributesMask

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<NodeAttributesMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<NodeClass> for NodeClass

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<NodeClass, StatusCode> where
    S: Read, 

impl BinaryEncoder<NodeIdType> for NodeIdType

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<NodeIdType, StatusCode> where
    S: Read, 

impl BinaryEncoder<OpenFileMode> for OpenFileMode

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<OpenFileMode, StatusCode> where
    S: Read, 

impl BinaryEncoder<OverrideValueHandling> for OverrideValueHandling

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<OverrideValueHandling, StatusCode> where
    S: Read, 

impl BinaryEncoder<PerformUpdateType> for PerformUpdateType

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<PerformUpdateType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PermissionType> for PermissionType

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<PermissionType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PubSubDiagnosticsCounterClassification> for PubSubDiagnosticsCounterClassification

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<PubSubDiagnosticsCounterClassification, StatusCode> where
    S: Read, 

impl BinaryEncoder<PubSubState> for PubSubState

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<PubSubState, StatusCode> where
    S: Read, 

impl BinaryEncoder<RedundancySupport> for RedundancySupport

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<RedundancySupport, StatusCode> where
    S: Read, 

impl BinaryEncoder<SecurityHeader> for SecurityHeader

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<SecurityTokenRequestType> for SecurityTokenRequestType

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<SecurityTokenRequestType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ServerState> for ServerState

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<ServerState, StatusCode> where
    S: Read, 

impl BinaryEncoder<StructureType> for StructureType

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<StructureType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SupportedMessage> for SupportedMessage

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<TimestampsToReturn> for TimestampsToReturn

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<TimestampsToReturn, StatusCode> where
    S: Read, 

impl BinaryEncoder<TrustListMasks> for TrustListMasks

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<TrustListMasks, StatusCode> where
    S: Read, 

impl BinaryEncoder<UadpDataSetMessageContentMask> for UadpDataSetMessageContentMask

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<UadpDataSetMessageContentMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<UadpNetworkMessageContentMask> for UadpNetworkMessageContentMask

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<UadpNetworkMessageContentMask, StatusCode> where
    S: Read, 

impl BinaryEncoder<UserTokenType> for UserTokenType

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<UserTokenType, StatusCode> where
    S: Read, 

impl BinaryEncoder<Variant> for Variant

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<Variant, StatusCode> where
    S: Read, 

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

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<Argument, StatusCode> where
    S: Read, 

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

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<Argument, StatusCode> where
    S: Read, 

impl BinaryEncoder<StatusCode> for StatusCode

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<StatusCode, StatusCode> where
    S: Read, 

impl BinaryEncoder<AcknowledgeMessage> for AcknowledgeMessage

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<AcknowledgeMessage, StatusCode> where
    S: Read, 

impl BinaryEncoder<ActivateSessionRequest> for ActivateSessionRequest

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<ActivateSessionRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<ActivateSessionResponse> for ActivateSessionResponse

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<ActivateSessionResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<AddNodesItem> for AddNodesItem

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<AddNodesItem, StatusCode> where
    S: Read, 

impl BinaryEncoder<AddNodesRequest> for AddNodesRequest

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<AddNodesRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<AddNodesResponse> for AddNodesResponse

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<AddNodesResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<AddNodesResult> for AddNodesResult

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<AddNodesResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<AddReferencesItem> for AddReferencesItem

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<AddReferencesItem, StatusCode> where
    S: Read, 

impl BinaryEncoder<AddReferencesRequest> for AddReferencesRequest

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<AddReferencesRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<AddReferencesResponse> for AddReferencesResponse

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<AddReferencesResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<AggregateConfiguration> for AggregateConfiguration

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<AggregateConfiguration, StatusCode> where
    S: Read, 

impl BinaryEncoder<AggregateFilter> for AggregateFilter

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<AggregateFilter, StatusCode> where
    S: Read, 

impl BinaryEncoder<AggregateFilterResult> for AggregateFilterResult

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<AggregateFilterResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<Annotation> for Annotation

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<Annotation, StatusCode> where
    S: Read, 

impl BinaryEncoder<AnonymousIdentityToken> for AnonymousIdentityToken

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<AnonymousIdentityToken, StatusCode> where
    S: Read, 

impl BinaryEncoder<ApplicationDescription> for ApplicationDescription

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<ApplicationDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<AsymmetricSecurityHeader> for AsymmetricSecurityHeader

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<AsymmetricSecurityHeader, StatusCode> where
    S: Read, 

impl BinaryEncoder<AttributeOperand> for AttributeOperand

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<AttributeOperand, StatusCode> where
    S: Read, 

impl BinaryEncoder<AxisInformation> for AxisInformation

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<AxisInformation, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrokerConnectionTransportDataType> for BrokerConnectionTransportDataType

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<BrokerConnectionTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrokerDataSetReaderTransportDataType> for BrokerDataSetReaderTransportDataType

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<BrokerDataSetReaderTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrokerDataSetWriterTransportDataType> for BrokerDataSetWriterTransportDataType

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<BrokerDataSetWriterTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrokerWriterGroupTransportDataType> for BrokerWriterGroupTransportDataType

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<BrokerWriterGroupTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowseDescription> for BrowseDescription

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<BrowseDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowseNextRequest> for BrowseNextRequest

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<BrowseNextRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowseNextResponse> for BrowseNextResponse

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<BrowseNextResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowsePath> for BrowsePath

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<BrowsePath, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowsePathResult> for BrowsePathResult

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<BrowsePathResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowsePathTarget> for BrowsePathTarget

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<BrowsePathTarget, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowseRequest> for BrowseRequest

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<BrowseRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowseResponse> for BrowseResponse

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<BrowseResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<BrowseResult> for BrowseResult

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<BrowseResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<BuildInfo> for BuildInfo

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<BuildInfo, StatusCode> where
    S: Read, 

impl BinaryEncoder<ByteString> for ByteString

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<ByteString, StatusCode> where
    S: Read, 

impl BinaryEncoder<CallMethodRequest> for CallMethodRequest

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<CallMethodRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<CallMethodResult> for CallMethodResult

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<CallMethodResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<CallRequest> for CallRequest

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<CallRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<CallResponse> for CallResponse

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<CallResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<CancelRequest> for CancelRequest

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<CancelRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<CancelResponse> for CancelResponse

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<CancelResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<CartesianCoordinates> for CartesianCoordinates

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<CartesianCoordinates, StatusCode> where
    S: Read, 

impl BinaryEncoder<ChannelSecurityToken> for ChannelSecurityToken

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<ChannelSecurityToken, StatusCode> where
    S: Read, 

impl BinaryEncoder<CloseSecureChannelRequest> for CloseSecureChannelRequest

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<CloseSecureChannelRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<CloseSecureChannelResponse> for CloseSecureChannelResponse

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<CloseSecureChannelResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<CloseSessionRequest> for CloseSessionRequest

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<CloseSessionRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<CloseSessionResponse> for CloseSessionResponse

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<CloseSessionResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<ComplexNumberType> for ComplexNumberType

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<ComplexNumberType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ConfigurationVersionDataType> for ConfigurationVersionDataType

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<ConfigurationVersionDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ConnectionTransportDataType> for ConnectionTransportDataType

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<ConnectionTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ContentFilter> for ContentFilter

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<ContentFilter, StatusCode> where
    S: Read, 

impl BinaryEncoder<ContentFilterElement> for ContentFilterElement

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<ContentFilterElement, StatusCode> where
    S: Read, 

impl BinaryEncoder<ContentFilterElementResult> for ContentFilterElementResult

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<ContentFilterElementResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<ContentFilterResult> for ContentFilterResult

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<ContentFilterResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<CreateMonitoredItemsRequest> for CreateMonitoredItemsRequest

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<CreateMonitoredItemsRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<CreateMonitoredItemsResponse> for CreateMonitoredItemsResponse

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<CreateMonitoredItemsResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<CreateSessionRequest> for CreateSessionRequest

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<CreateSessionRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<CreateSessionResponse> for CreateSessionResponse

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<CreateSessionResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<CreateSubscriptionRequest> for CreateSubscriptionRequest

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<CreateSubscriptionRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<CreateSubscriptionResponse> for CreateSubscriptionResponse

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<CreateSubscriptionResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataChangeFilter> for DataChangeFilter

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<DataChangeFilter, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataChangeNotification> for DataChangeNotification

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<DataChangeNotification, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetMetaDataType> for DataSetMetaDataType

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<DataSetMetaDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetReaderDataType> for DataSetReaderDataType

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<DataSetReaderDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetReaderMessageDataType> for DataSetReaderMessageDataType

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<DataSetReaderMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetReaderTransportDataType> for DataSetReaderTransportDataType

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<DataSetReaderTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetWriterDataType> for DataSetWriterDataType

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<DataSetWriterDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetWriterMessageDataType> for DataSetWriterMessageDataType

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<DataSetWriterMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataSetWriterTransportDataType> for DataSetWriterTransportDataType

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<DataSetWriterTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataTypeAttributes> for DataTypeAttributes

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<DataTypeAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataTypeDescription> for DataTypeDescription

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<DataTypeDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataTypeSchemaHeader> for DataTypeSchemaHeader

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<DataTypeSchemaHeader, StatusCode> where
    S: Read, 

impl BinaryEncoder<DataValue> for DataValue

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<DataValue, StatusCode> where
    S: Read, 

impl BinaryEncoder<DatagramConnectionTransportDataType> for DatagramConnectionTransportDataType

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<DatagramConnectionTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DatagramWriterGroupTransportDataType> for DatagramWriterGroupTransportDataType

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<DatagramWriterGroupTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DateTime> for DateTime

DateTime encoded as 64-bit signed int

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<DateTime, StatusCode> where
    S: Read, 

impl BinaryEncoder<DecimalDataType> for DecimalDataType

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<DecimalDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteAtTimeDetails> for DeleteAtTimeDetails

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<DeleteAtTimeDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteEventDetails> for DeleteEventDetails

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<DeleteEventDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteMonitoredItemsRequest> for DeleteMonitoredItemsRequest

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<DeleteMonitoredItemsRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteMonitoredItemsResponse> for DeleteMonitoredItemsResponse

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<DeleteMonitoredItemsResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteNodesItem> for DeleteNodesItem

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<DeleteNodesItem, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteNodesRequest> for DeleteNodesRequest

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<DeleteNodesRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteNodesResponse> for DeleteNodesResponse

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<DeleteNodesResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteRawModifiedDetails> for DeleteRawModifiedDetails

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<DeleteRawModifiedDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteReferencesItem> for DeleteReferencesItem

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<DeleteReferencesItem, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteReferencesRequest> for DeleteReferencesRequest

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<DeleteReferencesRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteReferencesResponse> for DeleteReferencesResponse

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<DeleteReferencesResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteSubscriptionsRequest> for DeleteSubscriptionsRequest

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<DeleteSubscriptionsRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<DeleteSubscriptionsResponse> for DeleteSubscriptionsResponse

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<DeleteSubscriptionsResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<DiagnosticInfo> for DiagnosticInfo

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<DiagnosticInfo, StatusCode> where
    S: Read, 

impl BinaryEncoder<DiscoveryConfiguration> for DiscoveryConfiguration

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<DiscoveryConfiguration, StatusCode> where
    S: Read, 

impl BinaryEncoder<DoubleComplexNumberType> for DoubleComplexNumberType

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<DoubleComplexNumberType, StatusCode> where
    S: Read, 

impl BinaryEncoder<EUInformation> for EUInformation

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<EUInformation, StatusCode> where
    S: Read, 

impl BinaryEncoder<ElementOperand> for ElementOperand

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<ElementOperand, StatusCode> where
    S: Read, 

impl BinaryEncoder<EndpointConfiguration> for EndpointConfiguration

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<EndpointConfiguration, StatusCode> where
    S: Read, 

impl BinaryEncoder<EndpointDescription> for EndpointDescription

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<EndpointDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<EndpointType> for EndpointType

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<EndpointType, StatusCode> where
    S: Read, 

impl BinaryEncoder<EndpointUrlListDataType> for EndpointUrlListDataType

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<EndpointUrlListDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<EnumDefinition> for EnumDefinition

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<EnumDefinition, StatusCode> where
    S: Read, 

impl BinaryEncoder<EnumDescription> for EnumDescription

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<EnumDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<EnumField> for EnumField

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<EnumField, StatusCode> where
    S: Read, 

impl BinaryEncoder<EnumValueType> for EnumValueType

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<EnumValueType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ErrorMessage> for ErrorMessage

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<ErrorMessage, StatusCode> where
    S: Read, 

impl BinaryEncoder<EventFieldList> for EventFieldList

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<EventFieldList, StatusCode> where
    S: Read, 

impl BinaryEncoder<EventFilter> for EventFilter

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<EventFilter, StatusCode> where
    S: Read, 

impl BinaryEncoder<EventFilterResult> for EventFilterResult

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<EventFilterResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<EventNotificationList> for EventNotificationList

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<EventNotificationList, StatusCode> where
    S: Read, 

impl BinaryEncoder<ExpandedNodeId> for ExpandedNodeId

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<ExpandedNodeId, StatusCode> where
    S: Read, 

impl BinaryEncoder<ExtensionObject> for ExtensionObject

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<ExtensionObject, StatusCode> where
    S: Read, 

impl BinaryEncoder<FieldMetaData> for FieldMetaData

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<FieldMetaData, StatusCode> where
    S: Read, 

impl BinaryEncoder<FieldTargetDataType> for FieldTargetDataType

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<FieldTargetDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<FilterOperand> for FilterOperand

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<FilterOperand, StatusCode> where
    S: Read, 

impl BinaryEncoder<FindServersOnNetworkRequest> for FindServersOnNetworkRequest

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<FindServersOnNetworkRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<FindServersOnNetworkResponse> for FindServersOnNetworkResponse

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<FindServersOnNetworkResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<FindServersRequest> for FindServersRequest

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<FindServersRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<FindServersResponse> for FindServersResponse

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<FindServersResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<Frame> for Frame

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<Frame, StatusCode> where
    S: Read, 

impl BinaryEncoder<GenericAttributeValue> for GenericAttributeValue

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<GenericAttributeValue, StatusCode> where
    S: Read, 

impl BinaryEncoder<GenericAttributes> for GenericAttributes

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<GenericAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<GetEndpointsRequest> for GetEndpointsRequest

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<GetEndpointsRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<GetEndpointsResponse> for GetEndpointsResponse

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<GetEndpointsResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<Guid> for Guid

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<Guid, StatusCode> where
    S: Read, 

impl BinaryEncoder<HelloMessage> for HelloMessage

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<HelloMessage, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryData> for HistoryData

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<HistoryData, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryEvent> for HistoryEvent

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<HistoryEvent, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryEventFieldList> for HistoryEventFieldList

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<HistoryEventFieldList, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryModifiedData> for HistoryModifiedData

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<HistoryModifiedData, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryReadDetails> for HistoryReadDetails

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<HistoryReadDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryReadRequest> for HistoryReadRequest

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<HistoryReadRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryReadResponse> for HistoryReadResponse

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<HistoryReadResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryReadResult> for HistoryReadResult

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<HistoryReadResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryReadValueId> for HistoryReadValueId

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<HistoryReadValueId, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryUpdateDetails> for HistoryUpdateDetails

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<HistoryUpdateDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryUpdateRequest> for HistoryUpdateRequest

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<HistoryUpdateRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryUpdateResponse> for HistoryUpdateResponse

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<HistoryUpdateResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<HistoryUpdateResult> for HistoryUpdateResult

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<HistoryUpdateResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<IdentityMappingRuleType> for IdentityMappingRuleType

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<IdentityMappingRuleType, StatusCode> where
    S: Read, 

impl BinaryEncoder<IssuedIdentityToken> for IssuedIdentityToken

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<IssuedIdentityToken, StatusCode> where
    S: Read, 

impl BinaryEncoder<JsonDataSetReaderMessageDataType> for JsonDataSetReaderMessageDataType

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<JsonDataSetReaderMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<JsonDataSetWriterMessageDataType> for JsonDataSetWriterMessageDataType

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<JsonDataSetWriterMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<JsonWriterGroupMessageDataType> for JsonWriterGroupMessageDataType

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<JsonWriterGroupMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<KeyValuePair> for KeyValuePair

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<KeyValuePair, StatusCode> where
    S: Read, 

impl BinaryEncoder<LiteralOperand> for LiteralOperand

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<LiteralOperand, StatusCode> where
    S: Read, 

impl BinaryEncoder<LocalizedText> for LocalizedText

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<LocalizedText, StatusCode> where
    S: Read, 

impl BinaryEncoder<MdnsDiscoveryConfiguration> for MdnsDiscoveryConfiguration

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<MdnsDiscoveryConfiguration, StatusCode> where
    S: Read, 

impl BinaryEncoder<MessageChunk> for MessageChunk

fn byte_len(&self) -> usize

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

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

impl BinaryEncoder<MessageChunkHeader> for MessageChunkHeader

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<MessageChunkHeader, StatusCode> where
    S: Read, 

impl BinaryEncoder<MessageHeader> for MessageHeader

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<MessageHeader, StatusCode> where
    S: Read, 

impl BinaryEncoder<MethodAttributes> for MethodAttributes

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<MethodAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<ModelChangeStructureDataType> for ModelChangeStructureDataType

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<ModelChangeStructureDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ModificationInfo> for ModificationInfo

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<ModificationInfo, StatusCode> where
    S: Read, 

impl BinaryEncoder<ModifyMonitoredItemsRequest> for ModifyMonitoredItemsRequest

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<ModifyMonitoredItemsRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<ModifyMonitoredItemsResponse> for ModifyMonitoredItemsResponse

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<ModifyMonitoredItemsResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<ModifySubscriptionRequest> for ModifySubscriptionRequest

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<ModifySubscriptionRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<ModifySubscriptionResponse> for ModifySubscriptionResponse

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<ModifySubscriptionResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoredItemCreateRequest> for MonitoredItemCreateRequest

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<MonitoredItemCreateRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoredItemCreateResult> for MonitoredItemCreateResult

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<MonitoredItemCreateResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoredItemModifyRequest> for MonitoredItemModifyRequest

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<MonitoredItemModifyRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoredItemModifyResult> for MonitoredItemModifyResult

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<MonitoredItemModifyResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoredItemNotification> for MonitoredItemNotification

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<MonitoredItemNotification, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoringFilter> for MonitoringFilter

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<MonitoringFilter, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoringFilterResult> for MonitoringFilterResult

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<MonitoringFilterResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<MonitoringParameters> for MonitoringParameters

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<MonitoringParameters, StatusCode> where
    S: Read, 

impl BinaryEncoder<NetworkAddressDataType> for NetworkAddressDataType

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<NetworkAddressDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<NetworkAddressUrlDataType> for NetworkAddressUrlDataType

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<NetworkAddressUrlDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<NetworkGroupDataType> for NetworkGroupDataType

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<NetworkGroupDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<NodeAttributes> for NodeAttributes

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<NodeAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<NodeId> for NodeId

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<NodeId, StatusCode> where
    S: Read, 

impl BinaryEncoder<NodeReference> for NodeReference

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<NodeReference, StatusCode> where
    S: Read, 

impl BinaryEncoder<NodeTypeDescription> for NodeTypeDescription

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<NodeTypeDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<NotificationData> for NotificationData

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<NotificationData, StatusCode> where
    S: Read, 

impl BinaryEncoder<NotificationMessage> for NotificationMessage

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<NotificationMessage, StatusCode> where
    S: Read, 

impl BinaryEncoder<ObjectAttributes> for ObjectAttributes

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<ObjectAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<ObjectTypeAttributes> for ObjectTypeAttributes

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<ObjectTypeAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<OpenSecureChannelRequest> for OpenSecureChannelRequest

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<OpenSecureChannelRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<OpenSecureChannelResponse> for OpenSecureChannelResponse

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<OpenSecureChannelResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<OptionSet> for OptionSet

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<OptionSet, StatusCode> where
    S: Read, 

impl BinaryEncoder<Orientation> for Orientation

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<Orientation, StatusCode> where
    S: Read, 

impl BinaryEncoder<ParsingResult> for ParsingResult

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<ParsingResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<ProgramDiagnostic2DataType> for ProgramDiagnostic2DataType

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<ProgramDiagnostic2DataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ProgramDiagnosticDataType> for ProgramDiagnosticDataType

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<ProgramDiagnosticDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PubSubConfigurationDataType> for PubSubConfigurationDataType

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<PubSubConfigurationDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PubSubConnectionDataType> for PubSubConnectionDataType

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<PubSubConnectionDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PubSubGroupDataType> for PubSubGroupDataType

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<PubSubGroupDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PublishRequest> for PublishRequest

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<PublishRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<PublishResponse> for PublishResponse

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<PublishResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<PublishedDataItemsDataType> for PublishedDataItemsDataType

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<PublishedDataItemsDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PublishedDataSetDataType> for PublishedDataSetDataType

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<PublishedDataSetDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PublishedDataSetSourceDataType> for PublishedDataSetSourceDataType

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<PublishedDataSetSourceDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PublishedEventsDataType> for PublishedEventsDataType

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<PublishedEventsDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<PublishedVariableDataType> for PublishedVariableDataType

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<PublishedVariableDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<QualifiedName> for QualifiedName

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<QualifiedName, StatusCode> where
    S: Read, 

impl BinaryEncoder<QueryDataDescription> for QueryDataDescription

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<QueryDataDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<QueryDataSet> for QueryDataSet

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<QueryDataSet, StatusCode> where
    S: Read, 

impl BinaryEncoder<QueryFirstRequest> for QueryFirstRequest

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<QueryFirstRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<QueryFirstResponse> for QueryFirstResponse

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<QueryFirstResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<QueryNextRequest> for QueryNextRequest

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<QueryNextRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<QueryNextResponse> for QueryNextResponse

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<QueryNextResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<Range> for Range

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<Range, StatusCode> where
    S: Read, 

impl BinaryEncoder<RationalNumber> for RationalNumber

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<RationalNumber, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReadAtTimeDetails> for ReadAtTimeDetails

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<ReadAtTimeDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReadEventDetails> for ReadEventDetails

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<ReadEventDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReadProcessedDetails> for ReadProcessedDetails

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<ReadProcessedDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReadRawModifiedDetails> for ReadRawModifiedDetails

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<ReadRawModifiedDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReadRequest> for ReadRequest

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<ReadRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReadResponse> for ReadResponse

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<ReadResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReadValueId> for ReadValueId

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<ReadValueId, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReaderGroupDataType> for ReaderGroupDataType

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<ReaderGroupDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReaderGroupMessageDataType> for ReaderGroupMessageDataType

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<ReaderGroupMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReaderGroupTransportDataType> for ReaderGroupTransportDataType

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<ReaderGroupTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<RedundantServerDataType> for RedundantServerDataType

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<RedundantServerDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReferenceDescription> for ReferenceDescription

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<ReferenceDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<ReferenceTypeAttributes> for ReferenceTypeAttributes

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<ReferenceTypeAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<RegisterNodesRequest> for RegisterNodesRequest

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<RegisterNodesRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<RegisterNodesResponse> for RegisterNodesResponse

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<RegisterNodesResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<RegisterServer2Request> for RegisterServer2Request

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<RegisterServer2Request, StatusCode> where
    S: Read, 

impl BinaryEncoder<RegisterServer2Response> for RegisterServer2Response

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<RegisterServer2Response, StatusCode> where
    S: Read, 

impl BinaryEncoder<RegisterServerRequest> for RegisterServerRequest

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<RegisterServerRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<RegisterServerResponse> for RegisterServerResponse

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<RegisterServerResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<RegisteredServer> for RegisteredServer

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<RegisteredServer, StatusCode> where
    S: Read, 

impl BinaryEncoder<RelativePath> for RelativePath

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<RelativePath, StatusCode> where
    S: Read, 

impl BinaryEncoder<RelativePathElement> for RelativePathElement

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<RelativePathElement, StatusCode> where
    S: Read, 

impl BinaryEncoder<RepublishRequest> for RepublishRequest

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<RepublishRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<RepublishResponse> for RepublishResponse

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<RepublishResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<RequestHeader> for RequestHeader

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<RequestHeader, StatusCode> where
    S: Read, 

impl BinaryEncoder<ResponseHeader> for ResponseHeader

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<ResponseHeader, StatusCode> where
    S: Read, 

impl BinaryEncoder<RolePermissionType> for RolePermissionType

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<RolePermissionType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SamplingIntervalDiagnosticsDataType> for SamplingIntervalDiagnosticsDataType

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<SamplingIntervalDiagnosticsDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SemanticChangeStructureDataType> for SemanticChangeStructureDataType

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<SemanticChangeStructureDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SequenceHeader> for SequenceHeader

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<SequenceHeader, StatusCode> where
    S: Read, 

impl BinaryEncoder<ServerDiagnosticsSummaryDataType> for ServerDiagnosticsSummaryDataType

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<ServerDiagnosticsSummaryDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ServerOnNetwork> for ServerOnNetwork

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<ServerOnNetwork, StatusCode> where
    S: Read, 

impl BinaryEncoder<ServerStatusDataType> for ServerStatusDataType

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<ServerStatusDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ServiceCounterDataType> for ServiceCounterDataType

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<ServiceCounterDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ServiceFault> for ServiceFault

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<ServiceFault, StatusCode> where
    S: Read, 

impl BinaryEncoder<SessionDiagnosticsDataType> for SessionDiagnosticsDataType

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<SessionDiagnosticsDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SessionSecurityDiagnosticsDataType> for SessionSecurityDiagnosticsDataType

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<SessionSecurityDiagnosticsDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SessionlessInvokeRequestType> for SessionlessInvokeRequestType

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<SessionlessInvokeRequestType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SessionlessInvokeResponseType> for SessionlessInvokeResponseType

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<SessionlessInvokeResponseType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SetMonitoringModeRequest> for SetMonitoringModeRequest

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<SetMonitoringModeRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<SetMonitoringModeResponse> for SetMonitoringModeResponse

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<SetMonitoringModeResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<SetPublishingModeRequest> for SetPublishingModeRequest

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<SetPublishingModeRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<SetPublishingModeResponse> for SetPublishingModeResponse

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<SetPublishingModeResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<SetTriggeringRequest> for SetTriggeringRequest

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<SetTriggeringRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<SetTriggeringResponse> for SetTriggeringResponse

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<SetTriggeringResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<SignatureData> for SignatureData

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<SignatureData, StatusCode> where
    S: Read, 

impl BinaryEncoder<SignedSoftwareCertificate> for SignedSoftwareCertificate

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<SignedSoftwareCertificate, StatusCode> where
    S: Read, 

impl BinaryEncoder<SimpleAttributeOperand> for SimpleAttributeOperand

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<SimpleAttributeOperand, StatusCode> where
    S: Read, 

impl BinaryEncoder<SimpleTypeDescription> for SimpleTypeDescription

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<SimpleTypeDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<StatusChangeNotification> for StatusChangeNotification

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<StatusChangeNotification, StatusCode> where
    S: Read, 

impl BinaryEncoder<StatusResult> for StatusResult

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<StatusResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<StructureDefinition> for StructureDefinition

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<StructureDefinition, StatusCode> where
    S: Read, 

impl BinaryEncoder<StructureDescription> for StructureDescription

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<StructureDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<StructureField> for StructureField

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<StructureField, StatusCode> where
    S: Read, 

impl BinaryEncoder<SubscribedDataSetDataType> for SubscribedDataSetDataType

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<SubscribedDataSetDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SubscribedDataSetMirrorDataType> for SubscribedDataSetMirrorDataType

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<SubscribedDataSetMirrorDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SubscriptionAcknowledgement> for SubscriptionAcknowledgement

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<SubscriptionAcknowledgement, StatusCode> where
    S: Read, 

impl BinaryEncoder<SubscriptionDiagnosticsDataType> for SubscriptionDiagnosticsDataType

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<SubscriptionDiagnosticsDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<SymmetricSecurityHeader> for SymmetricSecurityHeader

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<SymmetricSecurityHeader, StatusCode> where
    S: Read, 

impl BinaryEncoder<TargetVariablesDataType> for TargetVariablesDataType

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<TargetVariablesDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<ThreeDCartesianCoordinates> for ThreeDCartesianCoordinates

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<ThreeDCartesianCoordinates, StatusCode> where
    S: Read, 

impl BinaryEncoder<ThreeDFrame> for ThreeDFrame

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<ThreeDFrame, StatusCode> where
    S: Read, 

impl BinaryEncoder<ThreeDOrientation> for ThreeDOrientation

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<ThreeDOrientation, StatusCode> where
    S: Read, 

impl BinaryEncoder<ThreeDVector> for ThreeDVector

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<ThreeDVector, StatusCode> where
    S: Read, 

impl BinaryEncoder<TimeZoneDataType> for TimeZoneDataType

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<TimeZoneDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<TransferResult> for TransferResult

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<TransferResult, StatusCode> where
    S: Read, 

impl BinaryEncoder<TransferSubscriptionsRequest> for TransferSubscriptionsRequest

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<TransferSubscriptionsRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<TransferSubscriptionsResponse> for TransferSubscriptionsResponse

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<TransferSubscriptionsResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<TranslateBrowsePathsToNodeIdsRequest> for TranslateBrowsePathsToNodeIdsRequest

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<TranslateBrowsePathsToNodeIdsRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<TranslateBrowsePathsToNodeIdsResponse> for TranslateBrowsePathsToNodeIdsResponse

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<TranslateBrowsePathsToNodeIdsResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<TrustListDataType> for TrustListDataType

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<TrustListDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<UABinaryFileDataType> for UABinaryFileDataType

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<UABinaryFileDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<UAString> for UAString

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<UAString, StatusCode> where
    S: Read, 

impl BinaryEncoder<UadpDataSetReaderMessageDataType> for UadpDataSetReaderMessageDataType

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<UadpDataSetReaderMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<UadpDataSetWriterMessageDataType> for UadpDataSetWriterMessageDataType

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<UadpDataSetWriterMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<UadpWriterGroupMessageDataType> for UadpWriterGroupMessageDataType

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<UadpWriterGroupMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<UnregisterNodesRequest> for UnregisterNodesRequest

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<UnregisterNodesRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<UnregisterNodesResponse> for UnregisterNodesResponse

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<UnregisterNodesResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<UpdateDataDetails> for UpdateDataDetails

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<UpdateDataDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<UpdateEventDetails> for UpdateEventDetails

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<UpdateEventDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<UpdateStructureDataDetails> for UpdateStructureDataDetails

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<UpdateStructureDataDetails, StatusCode> where
    S: Read, 

impl BinaryEncoder<UserIdentityToken> for UserIdentityToken

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<UserIdentityToken, StatusCode> where
    S: Read, 

impl BinaryEncoder<UserNameIdentityToken> for UserNameIdentityToken

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<UserNameIdentityToken, StatusCode> where
    S: Read, 

impl BinaryEncoder<UserTokenPolicy> for UserTokenPolicy

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<UserTokenPolicy, StatusCode> where
    S: Read, 

impl BinaryEncoder<VariableAttributes> for VariableAttributes

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<VariableAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<VariableTypeAttributes> for VariableTypeAttributes

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<VariableTypeAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<Vector> for Vector

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<Vector, StatusCode> where
    S: Read, 

impl BinaryEncoder<ViewAttributes> for ViewAttributes

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<ViewAttributes, StatusCode> where
    S: Read, 

impl BinaryEncoder<ViewDescription> for ViewDescription

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<ViewDescription, StatusCode> where
    S: Read, 

impl BinaryEncoder<WriteRequest> for WriteRequest

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<WriteRequest, StatusCode> where
    S: Read, 

impl BinaryEncoder<WriteResponse> for WriteResponse

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<WriteResponse, StatusCode> where
    S: Read, 

impl BinaryEncoder<WriteValue> for WriteValue

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<WriteValue, StatusCode> where
    S: Read, 

impl BinaryEncoder<WriterGroupDataType> for WriterGroupDataType

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<WriterGroupDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<WriterGroupMessageDataType> for WriterGroupMessageDataType

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<WriterGroupMessageDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<WriterGroupTransportDataType> for WriterGroupTransportDataType

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<WriterGroupTransportDataType, StatusCode> where
    S: Read, 

impl BinaryEncoder<X509IdentityToken> for X509IdentityToken

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<X509IdentityToken, StatusCode> where
    S: Read, 

impl BinaryEncoder<XVType> for XVType

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<XVType, StatusCode> where
    S: Read, 

Loading content...