Struct opcua_server::prelude::status_code::StatusCode

pub struct StatusCode { /* private fields */ }

Implementations

impl StatusCode

pub const STATUS_MASK: StatusCode = Self{ bits: 4294901760,}

pub const BIT_MASK: StatusCode = Self{ bits: 65535,}

pub const IS_ERROR: StatusCode = Self{ bits: 2147483648,}

pub const IS_UNCERTAIN: StatusCode = Self{ bits: 1073741824,}

pub const HISTORICAL_RAW: StatusCode = Self{ bits: 0,}

pub const HISTORICAL_CALCULATED: StatusCode = Self{ bits: 1,}

pub const HISTORICAL_INTERPOLATED: StatusCode = Self{ bits: 2,}

pub const HISTORICAL_RESERVED: StatusCode = Self{ bits: 3,}

pub const HISTORICAL_PARTIAL: StatusCode = Self{ bits: 4,}

pub const HISTORICAL_EXTRA_DATA: StatusCode = Self{ bits: 8,}

pub const HISTORICAL_MULTI_VALUE: StatusCode = Self{ bits: 16,}

pub const OVERFLOW: StatusCode = Self{ bits: 128,}

pub const LIMIT_LOW: StatusCode = Self{ bits: 256,}

pub const LIMIT_HIGH: StatusCode = Self{ bits: 512,}

pub const LIMIT_CONSTANT: StatusCode = Self{ bits: 768,}

pub const LIMIT_DATA_VALUE: StatusCode = Self{ bits: 8192,}

pub const SEMANTICS_CHANGED: StatusCode = Self{ bits: 16384,}

pub const STRUCTURE_CHANGED: StatusCode = Self{ bits: 32768,}

pub const Good: StatusCode = Self{ bits: 0,}

pub const GoodSubscriptionTransferred: StatusCode = Self{ bits: 2949120,}

pub const GoodCompletesAsynchronously: StatusCode = Self{ bits: 3014656,}

pub const GoodOverload: StatusCode = Self{ bits: 3080192,}

pub const GoodClamped: StatusCode = Self{ bits: 3145728,}

pub const GoodLocalOverride: StatusCode = Self{ bits: 9830400,}

pub const GoodEntryInserted: StatusCode = Self{ bits: 10616832,}

pub const GoodEntryReplaced: StatusCode = Self{ bits: 10682368,}

pub const GoodNoData: StatusCode = Self{ bits: 10813440,}

pub const GoodMoreData: StatusCode = Self{ bits: 10878976,}

pub const GoodCommunicationEvent: StatusCode = Self{ bits: 10944512,}

pub const GoodShutdownEvent: StatusCode = Self{ bits: 11010048,}

pub const GoodCallAgain: StatusCode = Self{ bits: 11075584,}

pub const GoodNonCriticalTimeout: StatusCode = Self{ bits: 11141120,}

pub const GoodResultsMayBeIncomplete: StatusCode = Self{ bits: 12189696,}

pub const GoodDataIgnored: StatusCode = Self{ bits: 14221312,}

pub const GoodEdited: StatusCode = Self{ bits: 14417920,}

pub const GoodPostActionFailed: StatusCode = Self{ bits: 14483456,}

pub const GoodDependentValueChanged: StatusCode = Self{ bits: 14680064,}

pub const UncertainReferenceOutOfServer: StatusCode = Self{ bits: 1080819712,}

pub const UncertainNoCommunicationLastUsableValue: StatusCode = Self{ bits: 1083113472,}

pub const UncertainLastUsableValue: StatusCode = Self{ bits: 1083179008,}

pub const UncertainSubstituteValue: StatusCode = Self{ bits: 1083244544,}

pub const UncertainInitialValue: StatusCode = Self{ bits: 1083310080,}

pub const UncertainSensorNotAccurate: StatusCode = Self{ bits: 1083375616,}

pub const UncertainEngineeringUnitsExceeded: StatusCode = Self{ bits: 1083441152,}

pub const UncertainSubNormal: StatusCode = Self{ bits: 1083506688,}

pub const UncertainDataSubNormal: StatusCode = Self{ bits: 1084489728,}

pub const UncertainReferenceNotDeleted: StatusCode = Self{ bits: 1086062592,}

pub const UncertainNotAllNodesAvailable: StatusCode = Self{ bits: 1086324736,}

pub const UncertainDominantValueChanged: StatusCode = Self{ bits: 1088290816,}

pub const UncertainDependentValueChanged: StatusCode = Self{ bits: 1088552960,}

pub const BadUnexpectedError: StatusCode = Self{ bits: 2147549184,}

pub const BadInternalError: StatusCode = Self{ bits: 2147614720,}

pub const BadOutOfMemory: StatusCode = Self{ bits: 2147680256,}

pub const BadResourceUnavailable: StatusCode = Self{ bits: 2147745792,}

pub const BadCommunicationError: StatusCode = Self{ bits: 2147811328,}

pub const BadEncodingError: StatusCode = Self{ bits: 2147876864,}

pub const BadDecodingError: StatusCode = Self{ bits: 2147942400,}

pub const BadEncodingLimitsExceeded: StatusCode = Self{ bits: 2148007936,}

pub const BadUnknownResponse: StatusCode = Self{ bits: 2148073472,}

pub const BadTimeout: StatusCode = Self{ bits: 2148139008,}

pub const BadServiceUnsupported: StatusCode = Self{ bits: 2148204544,}

pub const BadShutdown: StatusCode = Self{ bits: 2148270080,}

pub const BadServerNotConnected: StatusCode = Self{ bits: 2148335616,}

pub const BadServerHalted: StatusCode = Self{ bits: 2148401152,}

pub const BadNothingToDo: StatusCode = Self{ bits: 2148466688,}

pub const BadTooManyOperations: StatusCode = Self{ bits: 2148532224,}

pub const BadDataTypeIdUnknown: StatusCode = Self{ bits: 2148597760,}

pub const BadCertificateInvalid: StatusCode = Self{ bits: 2148663296,}

pub const BadSecurityChecksFailed: StatusCode = Self{ bits: 2148728832,}

pub const BadCertificateTimeInvalid: StatusCode = Self{ bits: 2148794368,}

pub const BadCertificateIssuerTimeInvalid: StatusCode = Self{ bits: 2148859904,}

pub const BadCertificateHostNameInvalid: StatusCode = Self{ bits: 2148925440,}

pub const BadCertificateUriInvalid: StatusCode = Self{ bits: 2148990976,}

pub const BadCertificateUseNotAllowed: StatusCode = Self{ bits: 2149056512,}

pub const BadCertificateIssuerUseNotAllowed: StatusCode = Self{ bits: 2149122048,}

pub const BadCertificateUntrusted: StatusCode = Self{ bits: 2149187584,}

pub const BadCertificateRevocationUnknown: StatusCode = Self{ bits: 2149253120,}

pub const BadCertificateIssuerRevocationUnknown: StatusCode = Self{ bits: 2149318656,}

pub const BadCertificateRevoked: StatusCode = Self{ bits: 2149384192,}

pub const BadCertificateIssuerRevoked: StatusCode = Self{ bits: 2149449728,}

pub const BadUserAccessDenied: StatusCode = Self{ bits: 2149515264,}

pub const BadIdentityTokenInvalid: StatusCode = Self{ bits: 2149580800,}

pub const BadIdentityTokenRejected: StatusCode = Self{ bits: 2149646336,}

pub const BadSecureChannelIdInvalid: StatusCode = Self{ bits: 2149711872,}

pub const BadInvalidTimestamp: StatusCode = Self{ bits: 2149777408,}

pub const BadNonceInvalid: StatusCode = Self{ bits: 2149842944,}

pub const BadSessionIdInvalid: StatusCode = Self{ bits: 2149908480,}

pub const BadSessionClosed: StatusCode = Self{ bits: 2149974016,}

pub const BadSessionNotActivated: StatusCode = Self{ bits: 2150039552,}

pub const BadSubscriptionIdInvalid: StatusCode = Self{ bits: 2150105088,}

pub const BadRequestHeaderInvalid: StatusCode = Self{ bits: 2150236160,}

pub const BadTimestampsToReturnInvalid: StatusCode = Self{ bits: 2150301696,}

pub const BadRequestCancelledByClient: StatusCode = Self{ bits: 2150367232,}

pub const BadNoCommunication: StatusCode = Self{ bits: 2150694912,}

pub const BadWaitingForInitialData: StatusCode = Self{ bits: 2150760448,}

pub const BadNodeIdInvalid: StatusCode = Self{ bits: 2150825984,}

pub const BadNodeIdUnknown: StatusCode = Self{ bits: 2150891520,}

pub const BadAttributeIdInvalid: StatusCode = Self{ bits: 2150957056,}

pub const BadIndexRangeInvalid: StatusCode = Self{ bits: 2151022592,}

pub const BadIndexRangeNoData: StatusCode = Self{ bits: 2151088128,}

pub const BadDataEncodingInvalid: StatusCode = Self{ bits: 2151153664,}

pub const BadDataEncodingUnsupported: StatusCode = Self{ bits: 2151219200,}

pub const BadNotReadable: StatusCode = Self{ bits: 2151284736,}

pub const BadNotWritable: StatusCode = Self{ bits: 2151350272,}

pub const BadOutOfRange: StatusCode = Self{ bits: 2151415808,}

pub const BadNotSupported: StatusCode = Self{ bits: 2151481344,}

pub const BadNotFound: StatusCode = Self{ bits: 2151546880,}

pub const BadObjectDeleted: StatusCode = Self{ bits: 2151612416,}

pub const BadNotImplemented: StatusCode = Self{ bits: 2151677952,}

pub const BadMonitoringModeInvalid: StatusCode = Self{ bits: 2151743488,}

pub const BadMonitoredItemIdInvalid: StatusCode = Self{ bits: 2151809024,}

pub const BadMonitoredItemFilterInvalid: StatusCode = Self{ bits: 2151874560,}

pub const BadMonitoredItemFilterUnsupported: StatusCode = Self{ bits: 2151940096,}

pub const BadFilterNotAllowed: StatusCode = Self{ bits: 2152005632,}

pub const BadStructureMissing: StatusCode = Self{ bits: 2152071168,}

pub const BadEventFilterInvalid: StatusCode = Self{ bits: 2152136704,}

pub const BadContentFilterInvalid: StatusCode = Self{ bits: 2152202240,}

pub const BadFilterOperandInvalid: StatusCode = Self{ bits: 2152267776,}

pub const BadContinuationPointInvalid: StatusCode = Self{ bits: 2152333312,}

pub const BadNoContinuationPoints: StatusCode = Self{ bits: 2152398848,}

pub const BadReferenceTypeIdInvalid: StatusCode = Self{ bits: 2152464384,}

pub const BadBrowseDirectionInvalid: StatusCode = Self{ bits: 2152529920,}

pub const BadNodeNotInView: StatusCode = Self{ bits: 2152595456,}

pub const BadServerUriInvalid: StatusCode = Self{ bits: 2152660992,}

pub const BadServerNameMissing: StatusCode = Self{ bits: 2152726528,}

pub const BadDiscoveryUrlMissing: StatusCode = Self{ bits: 2152792064,}

pub const BadSempahoreFileMissing: StatusCode = Self{ bits: 2152857600,}

pub const BadRequestTypeInvalid: StatusCode = Self{ bits: 2152923136,}

pub const BadSecurityModeRejected: StatusCode = Self{ bits: 2152988672,}

pub const BadSecurityPolicyRejected: StatusCode = Self{ bits: 2153054208,}

pub const BadTooManySessions: StatusCode = Self{ bits: 2153119744,}

pub const BadUserSignatureInvalid: StatusCode = Self{ bits: 2153185280,}

pub const BadApplicationSignatureInvalid: StatusCode = Self{ bits: 2153250816,}

pub const BadNoValidCertificates: StatusCode = Self{ bits: 2153316352,}

pub const BadRequestCancelledByRequest: StatusCode = Self{ bits: 2153381888,}

pub const BadParentNodeIdInvalid: StatusCode = Self{ bits: 2153447424,}

pub const BadReferenceNotAllowed: StatusCode = Self{ bits: 2153512960,}

pub const BadNodeIdRejected: StatusCode = Self{ bits: 2153578496,}

pub const BadNodeIdExists: StatusCode = Self{ bits: 2153644032,}

pub const BadNodeClassInvalid: StatusCode = Self{ bits: 2153709568,}

pub const BadBrowseNameInvalid: StatusCode = Self{ bits: 2153775104,}

pub const BadBrowseNameDuplicated: StatusCode = Self{ bits: 2153840640,}

pub const BadNodeAttributesInvalid: StatusCode = Self{ bits: 2153906176,}

pub const BadTypeDefinitionInvalid: StatusCode = Self{ bits: 2153971712,}

pub const BadSourceNodeIdInvalid: StatusCode = Self{ bits: 2154037248,}

pub const BadTargetNodeIdInvalid: StatusCode = Self{ bits: 2154102784,}

pub const BadDuplicateReferenceNotAllowed: StatusCode = Self{ bits: 2154168320,}

pub const BadInvalidSelfReference: StatusCode = Self{ bits: 2154233856,}

pub const BadReferenceLocalOnly: StatusCode = Self{ bits: 2154299392,}

pub const BadNoDeleteRights: StatusCode = Self{ bits: 2154364928,}

pub const BadServerIndexInvalid: StatusCode = Self{ bits: 2154430464,}

pub const BadViewIdUnknown: StatusCode = Self{ bits: 2154496000,}

pub const BadTooManyMatches: StatusCode = Self{ bits: 2154627072,}

pub const BadQueryTooComplex: StatusCode = Self{ bits: 2154692608,}

pub const BadNoMatch: StatusCode = Self{ bits: 2154758144,}

pub const BadMaxAgeInvalid: StatusCode = Self{ bits: 2154823680,}

pub const BadHistoryOperationInvalid: StatusCode = Self{ bits: 2154889216,}

pub const BadHistoryOperationUnsupported: StatusCode = Self{ bits: 2154954752,}

pub const BadWriteNotSupported: StatusCode = Self{ bits: 2155020288,}

pub const BadTypeMismatch: StatusCode = Self{ bits: 2155085824,}

pub const BadMethodInvalid: StatusCode = Self{ bits: 2155151360,}

pub const BadArgumentsMissing: StatusCode = Self{ bits: 2155216896,}

pub const BadTooManySubscriptions: StatusCode = Self{ bits: 2155282432,}

pub const BadTooManyPublishRequests: StatusCode = Self{ bits: 2155347968,}

pub const BadNoSubscription: StatusCode = Self{ bits: 2155413504,}

pub const BadSequenceNumberUnknown: StatusCode = Self{ bits: 2155479040,}

pub const BadMessageNotAvailable: StatusCode = Self{ bits: 2155544576,}

pub const BadInsufficientClientProfile: StatusCode = Self{ bits: 2155610112,}

pub const BadTcpServerTooBusy: StatusCode = Self{ bits: 2155675648,}

pub const BadTcpMessageTypeInvalid: StatusCode = Self{ bits: 2155741184,}

pub const BadTcpSecureChannelUnknown: StatusCode = Self{ bits: 2155806720,}

pub const BadTcpMessageTooLarge: StatusCode = Self{ bits: 2155872256,}

pub const BadTcpNotEnoughResources: StatusCode = Self{ bits: 2155937792,}

pub const BadTcpInternalError: StatusCode = Self{ bits: 2156003328,}

pub const BadTcpEndpointUrlInvalid: StatusCode = Self{ bits: 2156068864,}

pub const BadRequestInterrupted: StatusCode = Self{ bits: 2156134400,}

pub const BadRequestTimeout: StatusCode = Self{ bits: 2156199936,}

pub const BadSecureChannelClosed: StatusCode = Self{ bits: 2156265472,}

pub const BadSecureChannelTokenUnknown: StatusCode = Self{ bits: 2156331008,}

pub const BadSequenceNumberInvalid: StatusCode = Self{ bits: 2156396544,}

pub const BadConfigurationError: StatusCode = Self{ bits: 2156462080,}

pub const BadNotConnected: StatusCode = Self{ bits: 2156527616,}

pub const BadDeviceFailure: StatusCode = Self{ bits: 2156593152,}

pub const BadSensorFailure: StatusCode = Self{ bits: 2156658688,}

pub const BadOutOfService: StatusCode = Self{ bits: 2156724224,}

pub const BadDeadbandFilterInvalid: StatusCode = Self{ bits: 2156789760,}

pub const BadRefreshInProgress: StatusCode = Self{ bits: 2157379584,}

pub const BadConditionAlreadyDisabled: StatusCode = Self{ bits: 2157445120,}

pub const BadConditionDisabled: StatusCode = Self{ bits: 2157510656,}

pub const BadEventIdUnknown: StatusCode = Self{ bits: 2157576192,}

pub const BadNoData: StatusCode = Self{ bits: 2157641728,}

pub const BadDataLost: StatusCode = Self{ bits: 2157772800,}

pub const BadDataUnavailable: StatusCode = Self{ bits: 2157838336,}

pub const BadEntryExists: StatusCode = Self{ bits: 2157903872,}

pub const BadNoEntryExists: StatusCode = Self{ bits: 2157969408,}

pub const BadTimestampNotSupported: StatusCode = Self{ bits: 2158034944,}

pub const BadInvalidArgument: StatusCode = Self{ bits: 2158690304,}

pub const BadConnectionRejected: StatusCode = Self{ bits: 2158755840,}

pub const BadDisconnect: StatusCode = Self{ bits: 2158821376,}

pub const BadConnectionClosed: StatusCode = Self{ bits: 2158886912,}

pub const BadInvalidState: StatusCode = Self{ bits: 2158952448,}

pub const BadEndOfStream: StatusCode = Self{ bits: 2159017984,}

pub const BadNoDataAvailable: StatusCode = Self{ bits: 2159083520,}

pub const BadWaitingForResponse: StatusCode = Self{ bits: 2159149056,}

pub const BadOperationAbandoned: StatusCode = Self{ bits: 2159214592,}

pub const BadExpectedStreamToBlock: StatusCode = Self{ bits: 2159280128,}

pub const BadWouldBlock: StatusCode = Self{ bits: 2159345664,}

pub const BadSyntaxError: StatusCode = Self{ bits: 2159411200,}

pub const BadMaxConnectionsReached: StatusCode = Self{ bits: 2159476736,}

pub const BadRequestTooLarge: StatusCode = Self{ bits: 2159542272,}

pub const BadResponseTooLarge: StatusCode = Self{ bits: 2159607808,}

pub const BadEventNotAcknowledgeable: StatusCode = Self{ bits: 2159738880,}

pub const BadInvalidTimestampArgument: StatusCode = Self{ bits: 2159869952,}

pub const BadProtocolVersionUnsupported: StatusCode = Self{ bits: 2159935488,}

pub const BadStateNotActive: StatusCode = Self{ bits: 2160001024,}

pub const BadFilterOperatorInvalid: StatusCode = Self{ bits: 2160132096,}

pub const BadFilterOperatorUnsupported: StatusCode = Self{ bits: 2160197632,}

pub const BadFilterOperandCountMismatch: StatusCode = Self{ bits: 2160263168,}

pub const BadFilterElementInvalid: StatusCode = Self{ bits: 2160328704,}

pub const BadFilterLiteralInvalid: StatusCode = Self{ bits: 2160394240,}

pub const BadIdentityChangeNotSupported: StatusCode = Self{ bits: 2160459776,}

pub const BadNotTypeDefinition: StatusCode = Self{ bits: 2160590848,}

pub const BadViewTimestampInvalid: StatusCode = Self{ bits: 2160656384,}

pub const BadViewParameterMismatch: StatusCode = Self{ bits: 2160721920,}

pub const BadViewVersionInvalid: StatusCode = Self{ bits: 2160787456,}

pub const BadConditionAlreadyEnabled: StatusCode = Self{ bits: 2160852992,}

pub const BadDialogNotActive: StatusCode = Self{ bits: 2160918528,}

pub const BadDialogResponseInvalid: StatusCode = Self{ bits: 2160984064,}

pub const BadConditionBranchAlreadyAcked: StatusCode = Self{ bits: 2161049600,}

pub const BadConditionBranchAlreadyConfirmed: StatusCode = Self{ bits: 2161115136,}

pub const BadConditionAlreadyShelved: StatusCode = Self{ bits: 2161180672,}

pub const BadConditionNotShelved: StatusCode = Self{ bits: 2161246208,}

pub const BadShelvingTimeOutOfRange: StatusCode = Self{ bits: 2161311744,}

pub const BadAggregateListMismatch: StatusCode = Self{ bits: 2161377280,}

pub const BadAggregateNotSupported: StatusCode = Self{ bits: 2161442816,}

pub const BadAggregateInvalidInputs: StatusCode = Self{ bits: 2161508352,}

pub const BadBoundNotFound: StatusCode = Self{ bits: 2161573888,}

pub const BadBoundNotSupported: StatusCode = Self{ bits: 2161639424,}

pub const BadAggregateConfigurationRejected: StatusCode = Self{ bits: 2161770496,}

pub const BadTooManyMonitoredItems: StatusCode = Self{ bits: 2161836032,}

pub const BadDominantValueChanged: StatusCode = Self{ bits: 2162229248,}

pub const BadDependentValueChanged: StatusCode = Self{ bits: 2162360320,}

pub const BadRequestNotAllowed: StatusCode = Self{ bits: 2162425856,}

pub const BadTooManyArguments: StatusCode = Self{ bits: 2162491392,}

pub const BadSecurityModeInsufficient: StatusCode = Self{ bits: 2162556928,}

pub const BadCertificateChainIncomplete: StatusCode = Self{ bits: 2165112832,}

pub const fn empty() -> StatusCode

Returns an empty set of flags.

pub const fn all() -> StatusCode

Returns the set containing all flags.

pub const fn bits(&self) -> u32

Returns the raw value of the flags currently stored.

pub const fn from_bits(bits: u32) -> Option<StatusCode>

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

pub const fn from_bits_truncate(bits: u32) -> StatusCode

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

pub const unsafe fn from_bits_unchecked(bits: u32) -> StatusCode

Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

Safety

The caller of the bitflags! macro can chose to allow or disallow extra bits for their bitflags type.

The caller of from_bits_unchecked() has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.

pub const fn is_empty(&self) -> bool

Returns true if no flags are currently stored.

pub const fn is_all(&self) -> bool

Returns true if all flags are currently set.

pub const fn intersects(&self, other: StatusCode) -> bool

Returns true if there are flags common to both self and other.

pub const fn contains(&self, other: StatusCode) -> bool

Returns true if all of the flags in other are contained within self.

pub fn insert(&mut self, other: StatusCode)

Inserts the specified flags in-place.

pub fn remove(&mut self, other: StatusCode)

Removes the specified flags in-place.

pub fn toggle(&mut self, other: StatusCode)

Toggles the specified flags in-place.

pub fn set(&mut self, other: StatusCode, value: bool)

Inserts or removes the specified flags depending on the passed value.

pub const fn intersection(self, other: StatusCode) -> StatusCode

Returns the intersection between the flags in self and other.

Specifically, the returned set contains only the flags which are present in both self and other.

This is equivalent to using the & operator (e.g. ops::BitAnd), as in flags & other.

pub const fn union(self, other: StatusCode) -> StatusCode

Returns the union of between the flags in self and other.

Specifically, the returned set contains all flags which are present in either self or other, including any which are present in both (see Self::symmetric_difference if that is undesirable).

This is equivalent to using the | operator (e.g. ops::BitOr), as in flags | other.

pub const fn difference(self, other: StatusCode) -> StatusCode

Returns the difference between the flags in self and other.

Specifically, the returned set contains all flags present in self, except for the ones present in other.

It is also conceptually equivalent to the “bit-clear” operation: flags & !other (and this syntax is also supported).

This is equivalent to using the - operator (e.g. ops::Sub), as in flags - other.

pub const fn symmetric_difference(self, other: StatusCode) -> StatusCode

Returns the symmetric difference between the flags in self and other.

Specifically, the returned set contains the flags present which are present in self or other, but that are not present in both. Equivalently, it contains the flags present in exactly one of the sets self and other.

This is equivalent to using the ^ operator (e.g. ops::BitXor), as in flags ^ other.

pub const fn complement(self) -> StatusCode

Returns the complement of this set of flags.

Specifically, the returned set contains all the flags which are not set in self, but which are allowed for this type.

Alternatively, it can be thought of as the set difference between Self::all() and self (e.g. Self::all() - self)

This is equivalent to using the ! operator (e.g. ops::Not), as in !flags.

impl StatusCode

pub fn is_bad(self) -> bool

Tests if the status code is bad

pub fn is_uncertain(self) -> bool

Tests if the status code is uncertain

pub fn is_good(self) -> bool

Tests if the status code is good (i.e. not bad or uncertain)

pub fn name(self) -> &'static str

Returns the descriptive name for the status code, e.g. to put a meaningful code in a log file

pub fn description(self) -> &'static str

Returns the descriptive text for the status code

pub fn from_u32(code: u32) -> Option<StatusCode>

Takes an OPC UA status code as a UInt32 and returns the matching StatusCode, assuming there is one Note that this is lossy since any bits associated with the status code will be ignored.

Trait Implementations

impl Binary for StatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl BinaryEncoder<StatusCode> for StatusCode

fn byte_len(&self) -> usize

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

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

Encodes the instance to the write stream.

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

Decodes an instance from the read stream. The decoding limits are restrictions set by the server / client on the length of strings, arrays etc. If these limits are exceeded the implementation should return with a BadDecodingError as soon as possible.

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

impl BitAnd<StatusCode> for StatusCode

fn bitand(self, other: StatusCode) -> StatusCode

Returns the intersection between the two sets of flags.

type Output = StatusCode

The resulting type after applying the & operator.

impl BitAndAssign<StatusCode> for StatusCode

fn bitand_assign(&mut self, other: StatusCode)

Disables all flags disabled in the set.

impl BitOr<StatusCode> for StatusCode

fn bitor(self, other: StatusCode) -> StatusCode

Returns the union of the two sets of flags.

type Output = StatusCode

The resulting type after applying the | operator.

impl BitOrAssign<StatusCode> for StatusCode

fn bitor_assign(&mut self, other: StatusCode)

Adds the set of flags.

impl BitXor<StatusCode> for StatusCode

fn bitxor(self, other: StatusCode) -> StatusCode

Returns the left flags, but with all the right flags toggled.

type Output = StatusCode

The resulting type after applying the ^ operator.

impl BitXorAssign<StatusCode> for StatusCode

fn bitxor_assign(&mut self, other: StatusCode)

Toggles the set of flags.

impl Clone for StatusCode

fn clone(&self) -> StatusCode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StatusCode

fn deserialize<D>(
    deserializer: D
) -> Result<StatusCode, <D as Deserializer<'de>>::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for StatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Extend<StatusCode> for StatusCode

fn extend<T>(&mut self, iterator: T)where
    T: IntoIterator<Item = StatusCode>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<StatusCode> for Variant

fn from(v: StatusCode) -> Variant

Converts to this type from the input type.

impl FromIterator<StatusCode> for StatusCode

fn from_iter<T>(iterator: T) -> StatusCodewhere
    T: IntoIterator<Item = StatusCode>,

Creates a value from an iterator.

impl FromStr for StatusCode

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<StatusCode, <StatusCode as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for StatusCode

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for StatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Not for StatusCode

fn not(self) -> StatusCode

Returns the complement of this set of flags.

type Output = StatusCode

The resulting type after applying the ! operator.

impl Octal for StatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Ord for StatusCode

fn cmp(&self, other: &StatusCode) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<StatusCode> for StatusCode

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

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

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

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

impl PartialOrd<StatusCode> for StatusCode

fn partial_cmp(&self, other: &StatusCode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for StatusCode

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

Serialize this value into the given Serde serializer.

impl Sub<StatusCode> for StatusCode

fn sub(self, other: StatusCode) -> StatusCode

Returns the set difference of the two sets of flags.

type Output = StatusCode

The resulting type after applying the - operator.

impl SubAssign<StatusCode> for StatusCode

fn sub_assign(&mut self, other: StatusCode)

Disables all flags enabled in the set.

impl UpperHex for StatusCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Copy for StatusCode

impl Eq for StatusCode

impl StructuralEq for StatusCode

impl StructuralPartialEq for StatusCode