Enum InstanceState

#[repr(u32)]
pub enum InstanceState {
    Alive = 1,
    NotAliveDisposed = 2,
    NotAliveNoWriters = 4,
}

Is this data instance alive or not and why.

The instance_state available in the SampleInfo is a snapshot of the instance_state of the instance at the time the collection was obtained (i.e., at the time read or take was called). The instance_state is therefore be the same for all samples in the returned collection that refer to the same instance.

DDS spec v1.4 Section “2.2.2.5.1.3 Interpretation of the SampleInfo instance_state”

Variants

Alive = 1

indicates that (a) samples have been received for the instance, (b) there are live DataWriter entities writing the instance, and (c) the instance has not been explicitly disposed (or else more samples have been received after it was disposed).

NotAliveDisposed = 2

indicates the instance was explicitly disposed by a DataWriter by means of the dispose operation.

NotAliveNoWriters = 4

indicates the instance has been declared as not-alive by the DataReader because it detected that there are no live DataWriter entities writing that instance

Implementations

impl InstanceState

pub fn any() -> BitFlags<Self>

Set that contains all possible states

pub fn not_alive() -> BitFlags<Self>

Set that contains both not_alive states.

Trait Implementations

impl BitAnd for InstanceState

type Output = BitFlags<InstanceState>

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self::Output

Performs the & operation.

impl BitFlag for InstanceState

fn empty() -> BitFlags<Self>

Create a BitFlags with no flags set (in other words, with a value of 0).

fn all() -> BitFlags<Self>

Create a BitFlags with all flags set.

fn from_bits(bits: Self::Numeric) -> Result<BitFlags<Self>, FromBitsError<Self>>

Create a BitFlags if the raw value provided does not contain any illegal flags.

fn from_bits_truncate(bits: Self::Numeric) -> BitFlags<Self>

Create a BitFlags from an underlying bitwise value. If any invalid bits are set, ignore them.

unsafe fn from_bits_unchecked(bits: Self::Numeric) -> BitFlags<Self>

Create a BitFlags unsafely, without checking if the bits form a valid bit pattern for the type.

impl BitOr for InstanceState

type Output = BitFlags<InstanceState>

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self::Output

Performs the | operation.

impl BitXor for InstanceState

type Output = BitFlags<InstanceState>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Self::Output

Performs the ^ operation.

impl Clone for InstanceState

fn clone(&self) -> InstanceState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InstanceState

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

Formats the value using the given formatter.

impl Not for InstanceState

type Output = BitFlags<InstanceState>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for InstanceState

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl RawBitFlags for InstanceState

const EMPTY: Self::Numeric = {transmute(0x00000000): <dds::sampleinfo::InstanceState as enumflags2::_internal::RawBitFlags>::Numeric}

A value with no bits set.

const DEFAULT: Self::Numeric = {transmute(0x00000000): <dds::sampleinfo::InstanceState as enumflags2::_internal::RawBitFlags>::Numeric}

The value used by the Default implementation. Equivalent to EMPTY, unless customized.

const ALL_BITS: Self::Numeric = {transmute(0x00000007): <dds::sampleinfo::InstanceState as enumflags2::_internal::RawBitFlags>::Numeric}

A value with all flag bits set.

const BITFLAGS_TYPE_NAME: &'static str = "BitFlags<InstanceState>"

The name of the type for debug formatting purposes.

type Numeric = u32

The underlying integer type.

fn bits(self) -> Self::Numeric

Return the bits as a number type.

impl Copy for InstanceState

impl Eq for InstanceState

impl StructuralPartialEq for InstanceState