Enum zbus::fdo::RequestNameFlags

source ·

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

Expand description

The flags used by the bus request_name method.

Variants§

§

AllowReplacement

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

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

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.

Enum zbus::fdo::RequestNameFlags

Variants§

AllowReplacement

ReplaceExisting

DoNotQueue

Trait Implementations§

impl BitAnd<RequestNameFlags> for RequestNameFlags

type Output = BitFlags<RequestNameFlags, <RequestNameFlags as RawBitFlags>::Numeric>

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

impl BitFlag for RequestNameFlags

fn empty() -> BitFlags<Self, Self::Numeric>

fn all() -> BitFlags<Self, Self::Numeric>

impl BitOr<RequestNameFlags> for RequestNameFlags

type Output = BitFlags<RequestNameFlags, <RequestNameFlags as RawBitFlags>::Numeric>

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

impl BitXor<RequestNameFlags> for RequestNameFlags

type Output = BitFlags<RequestNameFlags, <RequestNameFlags as RawBitFlags>::Numeric>

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

impl Clone for RequestNameFlags

fn clone(&self) -> RequestNameFlags

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

impl Debug for RequestNameFlags

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

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl Not for RequestNameFlags

type Output = BitFlags<RequestNameFlags, <RequestNameFlags as RawBitFlags>::Numeric>

fn not(self) -> Self::Output

impl PartialEq<RequestNameFlags> for RequestNameFlags

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

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

impl RawBitFlags for RequestNameFlags

type Numeric = u32

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

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

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

const BITFLAGS_TYPE_NAME: &'static str = _

fn bits(self) -> Self::Numeric

impl Serialize for RequestNameFlags

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

impl Type for RequestNameFlags

fn signature() -> Signature<'static>

impl Copy for RequestNameFlags

impl Eq for RequestNameFlags

impl StructuralEq for RequestNameFlags

impl StructuralPartialEq for RequestNameFlags

Auto Trait Implementations§

impl RefUnwindSafe for RequestNameFlags

impl Send for RequestNameFlags

impl Sync for RequestNameFlags

impl Unpin for RequestNameFlags

impl UnwindSafe for RequestNameFlags

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<'de, T> DynamicDeserialize<'de> for Twhere T: Type + Deserialize<'de> + ?Sized,

type Deserializer = PhantomData<T>

fn deserializer_for_signature<S>( signature: S ) -> Result<<T as DynamicDeserialize<'de>>::Deserializer, Error>where S: TryInto<Signature<'de>>, <S as TryInto<Signature<'de>>>::Error: Into<Error>,

impl<T> DynamicType for Twhere T: Type + ?Sized,

fn dynamic_signature(&self) -> Signature<'_>

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Same<T> for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

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

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