Enum RequestNameFlags

#[repr(u32)]
pub enum RequestNameFlags {
    AllowReplacement = 1,
    ReplaceExisting = 2,
    DoNotQueue = 4,
}

The flags used by the bus request_name method.

Variants

AllowReplacement = 1

If an application A specifies this flag and succeeds in becoming the owner of the name, and another application B later calls request_name with the ReplaceExisting flag, then application A will lose ownership and receive a org.freedesktop.DBus.NameLost signal, and application B will become the new owner. If AllowReplacement is not specified by application A, or ReplaceExisting is not specified by application B, then application B will not replace application A as the owner.

ReplaceExisting = 2

Try to replace the current owner if there is one. If this flag is not set the application will only become the owner of the name if there is no current owner. If this flag is set, the application will replace the current owner if the current owner specified AllowReplacement.

DoNotQueue = 4

Without this flag, if an application requests a name that is already owned, the application will be placed in a queue to own the name when the current owner gives it up. If this flag is given, the application will not be placed in the queue; the request for the name will simply fail. This flag also affects behavior when an application is replaced as name owner; by default the application moves back into the waiting queue, unless this flag was provided when the application became the name owner.

Trait Implementations

impl BitAnd for RequestNameFlags

type Output = BitFlags<RequestNameFlags>

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitFlag for RequestNameFlags

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 RequestNameFlags

type Output = BitFlags<RequestNameFlags>

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitXor for RequestNameFlags

type Output = BitFlags<RequestNameFlags>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl Clone for RequestNameFlags

fn clone(&self) -> RequestNameFlags

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RequestNameFlags

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RequestNameFlags

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Not for RequestNameFlags

type Output = BitFlags<RequestNameFlags>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for RequestNameFlags

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

const EMPTY: Self::Numeric = {transmute(0x00000000): <fdo::dbus::RequestNameFlags as enumflags2::_internal::RawBitFlags>::Numeric}

A value with no bits set.

const DEFAULT: Self::Numeric = {transmute(0x00000000): <fdo::dbus::RequestNameFlags as enumflags2::_internal::RawBitFlags>::Numeric}

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

const ALL_BITS: Self::Numeric = {transmute(0x00000007): <fdo::dbus::RequestNameFlags as enumflags2::_internal::RawBitFlags>::Numeric}

A value with all flag bits set.

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

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 Serialize for RequestNameFlags

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Type for RequestNameFlags

const SIGNATURE: &'static Signature = <u32 as ::zvariant::Type>::SIGNATURE

The signature for the implementing type, in parsed format.

impl Copy for RequestNameFlags

impl Eq for RequestNameFlags

impl StructuralPartialEq for RequestNameFlags