Enum SampleState

#[repr(u32)]
pub enum SampleState {
    Read = 1,
    NotRead = 2,
}

indicates whether or not the corresponding data sample has already been read by this DataReader.

For each sample received, the middleware internally maintains a sample_state relative to each DataReader. The sample_state can either be READ or NOT_READ.

The sample_state will, in general, be different for each sample in the collection returned by read() or take().

See DDS spec v1.4 Section 2.2.2.5.4 and Section “2.2.2.5.1.2 Interpretation of the SampleInfo sample_state”.

Variants

Read = 1

indicates that the DataReader has already accessed that sample by means of read() … or corresponding iterator.

NotRead = 2

indicates that the DataReader has not accessed that sample before

Implementations

impl SampleState

pub fn any() -> BitFlags<Self>

Set that contains all possible states

Trait Implementations

impl BitAnd for SampleState

type Output = BitFlags<SampleState>

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitFlag for SampleState

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 SampleState

type Output = BitFlags<SampleState>

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitXor for SampleState

type Output = BitFlags<SampleState>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl Clone for SampleState

fn clone(&self) -> SampleState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SampleState

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

Formats the value using the given formatter.

impl Not for SampleState

type Output = BitFlags<SampleState>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for SampleState

fn eq(&self, other: &SampleState) -> 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 SampleState

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

A value with no bits set.

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

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

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

A value with all flag bits set.

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

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 SampleState

impl Eq for SampleState

impl StructuralPartialEq for SampleState