Struct sawp_modbus::Flags

pub struct Flags<Enum, Primitive = <Enum as Flag>::Primitive> { /* private fields */ }

Re-export of the Flags struct that is used to represent bit flags in this crate. Storage type for handling flags

Implementations

impl<Enum> Flags<Enum, <Enum as Flag>::Primitive>where Enum: Flag,

pub fn from_flag(flag: Enum) -> Flags<Enum, <Enum as Flag>::Primitive>

Get a flag from a single enum value

pub fn from_bits( bits: <Enum as Flag>::Primitive ) -> Flags<Enum, <Enum as Flag>::Primitive>

Get a flag from a numeric value

Note: the value is unchecked so any bit may be set. Be careful because PartialEq is a direct comparison of underlying bits.

pub fn bits(&self) -> <Enum as Flag>::Primitive

Numeric representation of the variant

pub fn bits_ref(&self) -> &<Enum as Flag>::Primitive

Reference to numeric representation of the variant

pub fn intersects<B>(self, rhs: B) -> boolwhere B: Into<Flags<Enum, <Enum as Flag>::Primitive>>,

Check if at least one flag in common is set

pub fn contains<B>(self, rhs: B) -> boolwhere B: Into<Flags<Enum, <Enum as Flag>::Primitive>>,

Check if all flags provided in rhs are set

pub fn is_empty(&self) -> bool

pub fn is_all(&self) -> bool

Trait Implementations

impl<T> Binary for Flags<T, <T as Flag>::Primitive>where T: Flag,

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

Formats the value using the given formatter.

impl<T, B> BitAnd<B> for Flags<T, <T as Flag>::Primitive>where T: Flag, B: Into<Flags<T, <T as Flag>::Primitive>>,

type Output = Flags<T, <T as Flag>::Primitive>

The resulting type after applying the & operator.

fn bitand(self, other: B) -> Flags<T, <T as Flag>::Primitive>

Performs the & operation.

impl<T, B> BitAndAssign<B> for Flags<T, <T as Flag>::Primitive>where T: Flag, B: Into<Flags<T, <T as Flag>::Primitive>>,

fn bitand_assign(&mut self, rhs: B)

Performs the &= operation.

impl<T, B> BitOr<B> for Flags<T, <T as Flag>::Primitive>where T: Flag, B: Into<Flags<T, <T as Flag>::Primitive>>,

type Output = Flags<T, <T as Flag>::Primitive>

The resulting type after applying the | operator.

fn bitor(self, other: B) -> Flags<T, <T as Flag>::Primitive>

Performs the | operation.

impl<T, B> BitOrAssign<B> for Flags<T, <T as Flag>::Primitive>where T: Flag, B: Into<Flags<T, <T as Flag>::Primitive>>,

fn bitor_assign(&mut self, rhs: B)

Performs the |= operation.

impl<T, B> BitXor<B> for Flags<T, <T as Flag>::Primitive>where T: Flag, B: Into<Flags<T, <T as Flag>::Primitive>>,

type Output = Flags<T, <T as Flag>::Primitive>

The resulting type after applying the ^ operator.

fn bitxor(self, other: B) -> Flags<T, <T as Flag>::Primitive>

Performs the ^ operation.

impl<T, B> BitXorAssign<B> for Flags<T, <T as Flag>::Primitive>where T: Flag, B: Into<Flags<T, <T as Flag>::Primitive>>,

fn bitxor_assign(&mut self, rhs: B)

Performs the ^= operation.

impl<Enum, Primitive> Clone for Flags<Enum, Primitive>where Enum: Clone, Primitive: Clone,

fn clone(&self) -> Flags<Enum, Primitive>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Enum> Debug for Flags<Enum, <Enum as Flag>::Primitive>where Enum: Flag,

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

Formats the value using the given formatter.

impl<Enum> Default for Flags<Enum, <Enum as Flag>::Primitive>where Enum: Flag,

fn default() -> Flags<Enum, <Enum as Flag>::Primitive>

Returns the “default value” for a type.

impl<T> Display for Flags<T, <T as Flag>::Primitive>where T: Flag,

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

A pipe-separated list of set flags.

impl From<&Message> for Flags<CodeCategory>

fn from(msg: &Message) -> Self

Converts to this type from the input type.

impl<Enum> From<Enum> for Flags<Enum, <Enum as Flag>::Primitive>where Enum: Flag,

fn from(flag: Enum) -> Flags<Enum, <Enum as Flag>::Primitive>

Converts to this type from the input type.

impl From<FunctionCode> for Flags<AccessType>

fn from(code: FunctionCode) -> Self

Converts to this type from the input type.

impl<T> Not for Flags<T, <T as Flag>::Primitive>where T: Flag,

type Output = Flags<T, <T as Flag>::Primitive>

The resulting type after applying the ! operator.

fn not(self) -> <Flags<T, <T as Flag>::Primitive> as Not>::Output

Performs the unary ! operation.

impl<Enum> PartialEq<Enum> for Flags<Enum, <Enum as Flag>::Primitive>where Enum: Flag,

fn eq(&self, other: &Enum) -> 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 PartialEq<Flags<AccessType, <AccessType as Flag>::Primitive>> for AccessType

fn eq(&self, other: &Flags<Self>) -> 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 PartialEq<Flags<CodeCategory, <CodeCategory as Flag>::Primitive>> for CodeCategory

fn eq(&self, other: &Flags<Self>) -> 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<Enum, Primitive> PartialEq<Flags<Enum, Primitive>> for Flags<Enum, Primitive>where Enum: PartialEq<Enum>, Primitive: PartialEq<Primitive>,

fn eq(&self, other: &Flags<Enum, Primitive>) -> 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 PartialEq<Flags<ErrorFlags, <ErrorFlags as Flag>::Primitive>> for ErrorFlags

fn eq(&self, other: &Flags<Self>) -> 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<Enum, Primitive> Copy for Flags<Enum, Primitive>where Enum: Copy, Primitive: Copy,

impl<Enum, Primitive> Eq for Flags<Enum, Primitive>where Enum: Eq, Primitive: Eq,

impl<Enum, Primitive> StructuralEq for Flags<Enum, Primitive>

impl<Enum, Primitive> StructuralPartialEq for Flags<Enum, Primitive>