Trait dbus::arg::RefArg

pub trait RefArg: Debug + Send + Sync {
    fn arg_type(&self) -> ArgType;
    fn signature(&self) -> Signature<'static>;
    fn append(&self, _: &mut IterAppend<'_>);
    fn as_any(&self) -> &dyn Any
    where
        Self: 'static;
    fn as_any_mut(&mut self) -> &mut dyn Any
    where
        Self: 'static;
    fn box_clone(&self) -> Box<dyn RefArg + 'static>;

    fn as_i64(&self) -> Option<i64> { ... }
    fn as_u64(&self) -> Option<u64> { ... }
    fn as_f64(&self) -> Option<f64> { ... }
    fn as_str(&self) -> Option<&str> { ... }
    fn as_iter<'a>(
        &'a self
    ) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>> { ... }
    fn as_static_inner(&self, _index: usize) -> Option<&(dyn RefArg + 'static)>
    where
        Self: 'static,
    { ... }
    fn array_clone(_arg: &[Self]) -> Option<Box<dyn RefArg + 'static>>
    where
        Self: Sized,
    { ... }
}

Object safe version of Arg + Append + Get.

Required methods

fn arg_type(&self) -> ArgType

The corresponding D-Bus argument type code.

fn signature(&self) -> Signature<'static>

The corresponding D-Bus type signature for this type.

fn append(&self, _: &mut IterAppend<'_>)

Performs the append operation.

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

Transforms this argument to Any (which can be downcasted to read the current value).

If the type is an array, and the element type is byte, numeric, boolean, or string, then the representation is guaranteed to be a Vec. Arrays of structs, dicts, and so on are not safe to use with this.

Note: The internal representation of complex types (Dict, Struct) is unstable and as_any should not be relied upon for these types. Use as_iter instead.

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

Transforms this argument to Any (which can be downcasted to read the current value).

If the type is an array, and the element type is byte, numeric, boolean, or string, then the representation is guaranteed to be a Vec. Arrays of structs, dicts, and so on are not safe to use with this.

Note: The internal representation of complex types (Dict, Struct) is unstable and as_any should not be relied upon for these types. Use as_iter instead.

Panic

Will panic if the interior cannot be made mutable, e g, if encapsulated inside a Rc with a reference count > 1.

fn box_clone(&self) -> Box<dyn RefArg + 'static>

Deep clone of the RefArg, causing the result to be 'static.

Usable as an escape hatch in case of lifetime problems with RefArg.

In case of complex types (Array, Dict, Struct), the clone is not guaranteed to have the same internal representation as the original.

Loading content...

Provided methods

fn as_i64(&self) -> Option<i64>

Try to read the argument as an i64.

Works for: Boolean, Byte, Int16, UInt16, Int32, UInt32, Int64, UnixFd.

fn as_u64(&self) -> Option<u64>

Try to read the argument as an u64.

Works for: Boolean, Byte, Int16, UInt16, Int32, UInt32, UInt64.

fn as_f64(&self) -> Option<f64>

Try to read the argument as an f64.

Works for: Boolean, Byte, Int16, UInt16, Int32, UInt32, Double.

fn as_str(&self) -> Option<&str>

Try to read the argument as a str.

Works for: String, ObjectPath, Signature.

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

Try to read the argument as an iterator.

Works for: Array/Dict, Struct, Variant. For Dicts, keys and values are interleaved.

fn as_static_inner(&self, _index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

Try to read the inner of an argument, as another argument, specifying an index.

Works for: Variant, Array, Struct, Dict. For Dicts, even indices gets a key, odd indices gets a value.

fn array_clone(_arg: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

Deep clone of an array.

This method is used internally by box_clone.

Loading content...

Implementations on Foreign Types

impl<'a, T: RefArg + ?Sized> RefArg for &'a T

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    T: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    T: 'static, 

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn as_str(&self) -> Option<&str>

fn as_iter<'b>(
    &'b self
) -> Option<Box<dyn Iterator<Item = &'b dyn RefArg> + 'b>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<T: RefArg + ?Sized> RefArg for Box<T>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    T: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    T: 'static, 

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn as_str(&self) -> Option<&str>

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<T: RefArg + ?Sized> RefArg for Arc<T>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    T: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    T: 'static, 

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn as_str(&self) -> Option<&str>

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl RefArg for u8

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for i16

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for u16

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for i32

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for u32

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for i64

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for u64

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for bool

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for f64

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for String

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for File

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg> RefArg for (A,)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg> RefArg for (A, B)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg> RefArg for (A, B, C)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg> RefArg for (A, B, C, D)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg, E: RefArg> RefArg for (A, B, C, D, E)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg, E: RefArg, F: RefArg> RefArg for (A, B, C, D, E, F)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg, E: RefArg, F: RefArg, G: RefArg> RefArg for (A, B, C, D, E, F, G)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg, E: RefArg, F: RefArg, G: RefArg, H: RefArg> RefArg for (A, B, C, D, E, F, G, H)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg, E: RefArg, F: RefArg, G: RefArg, H: RefArg, I: RefArg> RefArg for (A, B, C, D, E, F, G, H, I)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg, E: RefArg, F: RefArg, G: RefArg, H: RefArg, I: RefArg, J: RefArg> RefArg for (A, B, C, D, E, F, G, H, I, J)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg, E: RefArg, F: RefArg, G: RefArg, H: RefArg, I: RefArg, J: RefArg, K: RefArg> RefArg for (A, B, C, D, E, F, G, H, I, J, K)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<A: RefArg, B: RefArg, C: RefArg, D: RefArg, E: RefArg, F: RefArg, G: RefArg, H: RefArg, I: RefArg, J: RefArg, K: RefArg, L: RefArg> RefArg for (A, B, C, D, E, F, G, H, I, J, K, L)

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl RefArg for VecDeque<Box<dyn RefArg>>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<'a, T: Arg + RefArg> RefArg for &'a [T]

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<T: Arg + RefArg> RefArg for Vec<T>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<K: DictKey + RefArg + Eq + Hash, V: RefArg + Arg, S: BuildHasher + Send + Sync> RefArg for HashMap<K, V, S>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn as_iter<'b>(
    &'b self
) -> Option<Box<dyn Iterator<Item = &'b dyn RefArg> + 'b>>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

Loading content...

Implementors

impl RefArg for MessageItem

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl RefArg for OwnedFd

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for ErrorName<'static>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for Interface<'static>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for Member<'static>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for Path<'static>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl RefArg for Signature<'static>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn as_str(&self) -> Option<&str>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn array_clone(v: &[Self]) -> Option<Box<dyn RefArg + 'static>> where
    Self: Sized, 

impl<'a, T, I> RefArg for Array<'static, T, I> where
    T: 'a + Arg + RefArg,
    I: Debug + Clone + Send + Sync + Iterator<Item = &'a T>, 

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    Self: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    Self: 'static, 

fn box_clone(&self) -> Box<dyn RefArg + 'static>

impl<T: RefArg> RefArg for Variant<T>

fn arg_type(&self) -> ArgType

fn signature(&self) -> Signature<'static>

fn append(&self, i: &mut IterAppend<'_>)

fn as_any(&self) -> &dyn Any where
    T: 'static, 

fn as_any_mut(&mut self) -> &mut dyn Any where
    T: 'static, 

fn as_i64(&self) -> Option<i64>

fn as_u64(&self) -> Option<u64>

fn as_f64(&self) -> Option<f64>

fn as_str(&self) -> Option<&str>

fn as_iter<'a>(
    &'a self
) -> Option<Box<dyn Iterator<Item = &'a dyn RefArg> + 'a>>

fn box_clone(&self) -> Box<dyn RefArg + 'static>

fn as_static_inner(&self, index: usize) -> Option<&(dyn RefArg + 'static)> where
    Self: 'static, 

Loading content...