1.0.0[−][src]Trait uefi_std::default::Default

pub trait Default {
    fn default() -> Self;
}

A trait for giving a type a useful default value.

Sometimes, you want to fall back to some kind of default value, and don't particularly care what it is. This comes up often with structs that define a set of options:

struct SomeOptions {
    foo: i32,
    bar: f32,
}

How can we define some default values? You can use Default:

#[derive(Default)]
struct SomeOptions {
    foo: i32,
    bar: f32,
}

fn main() {
    let options: SomeOptions = Default::default();
}

Now, you get all of the default values. Rust implements Default for various primitives types.

If you want to override a particular option, but still retain the other defaults:

fn main() {
    let options = SomeOptions { foo: 42, ..Default::default() };
}

Derivable

This trait can be used with #[derive] if all of the type's fields implement Default. When derived, it will use the default value for each field's type.

How can I implement `Default`?

Provides an implementation for the default() method that returns the value of your type that should be the default:

enum Kind {
    A,
    B,
    C,
}

impl Default for Kind {
    fn default() -> Self { Kind::A }
}

Examples

#[derive(Default)]
struct SomeOptions {
    foo: i32,
    bar: f32,
}

Required methods

`fn default() -> Self`

Returns the "default value" for a type.

Default values are often some kind of initial value, identity value, or anything else that may make sense as a default.

Examples

Using built-in default values:

let i: i8 = Default::default();
let (x, y): (Option<String>, f64) = Default::default();
let (a, b, (c, d)): (i32, u32, (bool, bool)) = Default::default();

Making your own:

enum Kind {
    A,
    B,
    C,
}

impl Default for Kind {
    fn default() -> Self { Kind::A }
}

Loading content...

Implementations on Foreign Types

`impl<T> Default for AtomicPtr<T>`[src]

`fn default() -> AtomicPtr<T>`[src]

Creates a null AtomicPtr<T>.

`impl Default for AtomicI16`[src]

`fn default() -> AtomicI16`[src]

`impl Default for AtomicU8`[src]

`fn default() -> AtomicU8`[src]

`impl Default for AtomicUsize`[src]

`fn default() -> AtomicUsize`[src]

`impl Default for Duration`[src]

`fn default() -> Duration`[src]

`impl Default for AtomicBool`[src]

`fn default() -> AtomicBool`[src]

Creates an AtomicBool initialized to false.

`impl Default for AtomicI8`[src]

`fn default() -> AtomicI8`[src]

`impl<T> Default for Wrapping<T> where T: Default,` [src]

`fn default() -> Wrapping<T>`[src]

`impl Default for AtomicI64`[src]

`fn default() -> AtomicI64`[src]

`impl Default for AtomicI32`[src]

`fn default() -> AtomicI32`[src]

`impl Default for AtomicIsize`[src]

`fn default() -> AtomicIsize`[src]

`impl Default for AtomicU32`[src]

`fn default() -> AtomicU32`[src]

`impl Default for AtomicU16`[src]

`fn default() -> AtomicU16`[src]

`impl Default for AtomicU64`[src]

`fn default() -> AtomicU64`[src]

`impl Default for Global`[src]

`fn default() -> Global`[src]

`impl<T> Default for Weak<T>`[src]

`fn default() -> Weak<T>`[src]

Constructs a new Weak<T>, without allocating memory. Calling upgrade on the return value always gives None.

Examples

use std::sync::Weak;

let empty: Weak<i64> = Default::default();
assert!(empty.upgrade().is_none());

`impl<T> Default for Arc<T> where T: Default,` [src]

`fn default() -> Arc<T>`[src]

Creates a new Arc<T>, with the Default value for T.

Examples

use std::sync::Arc;

let x: Arc<i32> = Default::default();
assert_eq!(*x, 0);

`impl Default for MemoryDescriptor`

`fn default() -> MemoryDescriptor`

`impl Default for Time`

`fn default() -> Time`

`impl Default for VirtualAddress`

`fn default() -> VirtualAddress`

`impl Default for TimeCapabilities`

`fn default() -> TimeCapabilities`

`impl Default for PhysicalAddress`

`fn default() -> PhysicalAddress`

`impl Default for TextInputKey`

`fn default() -> TextInputKey`

`impl Default for SimplePointerState`

`fn default() -> SimplePointerState`

`impl Default for FileInfo`

`fn default() -> FileInfo`

Loading content...

Implementors

`impl Default for ()`[src]

`fn default()`[src]

Returns the default value of ()

`impl Default for Box<str>`[src]

ⓘImportant traits for Box<F>
Important traits for Box<F>
`impl<F> Future for Box<F> where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl Iterator for Box where I: Iterator + ?Sized, type Item = ::Item;`
`fn default() -> Box<str>`[src]

`impl Default for Error`[src]

`fn default() -> Error`[src]

`impl Default for SipHasher`[src]

`fn default() -> SipHasher`[src]

`impl Default for String`[src]

`fn default() -> String`[src]

Creates an empty String.

`impl Default for bool`[src]

`fn default() -> bool`[src]

Returns the default value of false

`impl Default for char`[src]

`fn default() -> char`[src]

Returns the default value of \x00

`impl Default for f32`[src]

`fn default() -> f32`[src]

Returns the default value of 0.0

`impl Default for f64`[src]