Trait bevy_tilemap::From

pub trait From<T> {
#[lang = "from"]    fn from(T) -> Self;
}

Used to do value-to-value conversions while consuming the input value. It is the reciprocal of Into.

One should always prefer implementing From over Into because implementing From automatically provides one with an implementation of Into thanks to the blanket implementation in the standard library.

Only implement Into when targeting a version prior to Rust 1.41 and converting to a type outside the current crate. From was not able to do these types of conversions in earlier versions because of Rust's orphaning rules. See Into for more details.

Prefer using Into over using From when specifying trait bounds on a generic function. This way, types that directly implement Into can be used as arguments as well.

The From is also very useful when performing error handling. When constructing a function that is capable of failing, the return type will generally be of the form Result<T, E>. The From trait simplifies error handling by allowing a function to return a single error type that encapsulate multiple error types. See the "Examples" section and the book for more details.

Note: This trait must not fail. If the conversion can fail, use TryFrom.

Generic Implementations

• From<T> for U implies Into<U> for T
• From is reflexive, which means that From<T> for T is implemented

Examples

String implements From<&str>:

An explicit conversion from a &str to a String is done as follows:

let string = "hello".to_string();
let other_string = String::from("hello");

assert_eq!(string, other_string);

While performing error handling it is often useful to implement From for your own error type. By converting underlying error types to our own custom error type that encapsulates the underlying error type, we can return a single error type without losing information on the underlying cause. The '?' operator automatically converts the underlying error type to our custom error type by calling Into<CliError>::into which is automatically provided when implementing From. The compiler then infers which implementation of Into should be used.

use std::fs;
use std::io;
use std::num;

enum CliError {
    IoError(io::Error),
    ParseError(num::ParseIntError),
}

impl From<io::Error> for CliError {
    fn from(error: io::Error) -> Self {
        CliError::IoError(error)
    }
}

impl From<num::ParseIntError> for CliError {
    fn from(error: num::ParseIntError) -> Self {
        CliError::ParseError(error)
    }
}

fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> {
    let mut contents = fs::read_to_string(&file_name)?;
    let num: i32 = contents.trim().parse()?;
    Ok(num)
}

Required methods

#[lang = "from"]fn from(T) -> Self

Performs the conversion.

Loading content...

Implementations on Foreign Types

impl<'_> From<&'_ CStr> for Rc<CStr>

pub fn from(s: &CStr) -> Rc<CStr>

impl<I> From<(I, u16)> for SocketAddr where
    I: Into<IpAddr>, 

pub fn from(pieces: (I, u16)) -> SocketAddr

Converts a tuple struct (Into<IpAddr>, u16) into a SocketAddr.

This conversion creates a SocketAddr::V4 for a IpAddr::V4 and creates a SocketAddr::V6 for a IpAddr::V6.

u16 is treated as port of the newly created SocketAddr.

impl From<[u8; 4]> for Ipv4Addr

pub fn from(octets: [u8; 4]) -> Ipv4Addr

Creates an Ipv4Addr from a four element byte array.

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);

impl From<[u8; 16]> for IpAddr

pub fn from(octets: [u8; 16]) -> IpAddr

Creates an IpAddr::V6 from a sixteen element byte array.

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = IpAddr::from([
    25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
    17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x1918, 0x1716,
        0x1514, 0x1312,
        0x1110, 0x0f0e,
        0x0d0c, 0x0b0a
    )),
    addr
);

impl<'_, T> From<&'_ T> for OsString where
    T: AsRef<OsStr> + ?Sized, 

pub fn from(s: &T) -> OsString

impl From<String> for OsString

pub fn from(s: String) -> OsString

Converts a String into a OsString.

The conversion copies the data, and includes an allocation on the heap.

impl From<SocketAddrV6> for SocketAddr

pub fn from(sock6: SocketAddrV6) -> SocketAddr

Converts a SocketAddrV6 into a SocketAddr::V6.

impl<'a> From<&'a Path> for Cow<'a, Path>

pub fn from(s: &'a Path) -> Cow<'a, Path>

impl From<Vec<NonZeroU8>> for CString

pub fn from(v: Vec<NonZeroU8>) -> CString

Converts a Vec<NonZeroU8> into a CString without copying nor checking for inner null bytes.

impl<'a> From<Cow<'a, Path>> for PathBuf

pub fn from(p: Cow<'a, Path>) -> PathBuf

impl<'_> From<&'_ Path> for Rc<Path>

pub fn from(s: &Path) -> Rc<Path>

Converts a Path into an Rc by copying the Path data into a new Rc buffer.

impl<'a> From<&'a OsStr> for Cow<'a, OsStr>

pub fn from(s: &'a OsStr) -> Cow<'a, OsStr>

impl<'a> From<Cow<'a, OsStr>> for OsString

pub fn from(s: Cow<'a, OsStr>) -> OsString

impl From<Box<OsStr>> for OsString

pub fn from(boxed: Box<OsStr>) -> OsString

Converts a Box<OsStr> into a OsString without copying or allocating.

impl From<ChildStderr> for Stdio

pub fn from(child: ChildStderr) -> Stdio

Converts a ChildStderr into a Stdio

Examples

use std::process::{Command, Stdio};

let reverse = Command::new("rev")
    .arg("non_existing_file.txt")
    .stderr(Stdio::piped())
    .spawn()
    .expect("failed reverse command");

let cat = Command::new("cat")
    .arg("-")
    .stdin(reverse.stderr.unwrap()) // Converted into a Stdio here
    .output()
    .expect("failed echo command");

assert_eq!(
    String::from_utf8_lossy(&cat.stdout),
    "rev: cannot open non_existing_file.txt: No such file or directory\n"
);

impl<T> From<T> for RwLock<T>

pub fn from(t: T) -> RwLock<T>

Creates a new instance of an RwLock<T> which is unlocked. This is equivalent to RwLock::new.

impl<'a> From<CString> for Cow<'a, CStr>

pub fn from(s: CString) -> Cow<'a, CStr>

impl From<OsString> for Rc<OsStr>

pub fn from(s: OsString) -> Rc<OsStr>

Converts a OsString into a Rc<OsStr> without copying or allocating.

impl From<NulError> for Error

pub fn from(NulError) -> Error

Converts a NulError into a io::Error.

impl From<Ipv4Addr> for u32

pub fn from(ip: Ipv4Addr) -> u32

Converts an Ipv4Addr into a host byte order u32.

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(0xca, 0xfe, 0xba, 0xbe);
assert_eq!(0xcafebabe, u32::from(addr));

impl<'a> From<OsString> for Cow<'a, OsStr>

pub fn from(s: OsString) -> Cow<'a, OsStr>

impl From<[u16; 8]> for IpAddr

pub fn from(segments: [u16; 8]) -> IpAddr

Creates an IpAddr::V6 from an eight element 16-bit array.

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = IpAddr::from([
    525u16, 524u16, 523u16, 522u16,
    521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x20d, 0x20c,
        0x20b, 0x20a,
        0x209, 0x208,
        0x207, 0x206
    )),
    addr
);

impl<'a> From<&'a OsString> for Cow<'a, OsStr>

pub fn from(s: &'a OsString) -> Cow<'a, OsStr>

impl From<[u8; 4]> for IpAddr

pub fn from(octets: [u8; 4]) -> IpAddr

Creates an IpAddr::V4 from a four element byte array.

Examples

use std::net::{IpAddr, Ipv4Addr};

let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);

impl From<Box<CStr>> for CString

pub fn from(s: Box<CStr>) -> CString

Converts a Box<CStr> into a CString without copying or allocating.

impl<'_, T> From<&'_ T> for PathBuf where
    T: AsRef<OsStr> + ?Sized, 

pub fn from(s: &T) -> PathBuf

impl<'a> From<&'a PathBuf> for Cow<'a, Path>

pub fn from(p: &'a PathBuf) -> Cow<'a, Path>

impl<T> From<PoisonError<T>> for TryLockError<T>

pub fn from(err: PoisonError<T>) -> TryLockError<T>

impl From<Ipv6Addr> for u128

pub fn from(ip: Ipv6Addr) -> u128

Convert an Ipv6Addr into a host byte order u128.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::new(
    0x1020, 0x3040, 0x5060, 0x7080,
    0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
);
assert_eq!(0x102030405060708090A0B0C0D0E0F00D_u128, u128::from(addr));

impl<'_> From<&'_ CStr> for CString

pub fn from(s: &CStr) -> CString

impl From<[u16; 8]> for Ipv6Addr

pub fn from(segments: [u16; 8]) -> Ipv6Addr

Creates an Ipv6Addr from an eight element 16-bit array.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    525u16, 524u16, 523u16, 522u16,
    521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
    Ipv6Addr::new(
        0x20d, 0x20c,
        0x20b, 0x20a,
        0x209, 0x208,
        0x207, 0x206
    ),
    addr
);

impl From<String> for PathBuf

pub fn from(s: String) -> PathBuf

Converts a String into a PathBuf

This conversion does not allocate or copy memory.

impl From<PathBuf> for OsString

pub fn from(path_buf: PathBuf) -> OsString

Converts a PathBuf into a OsString

This conversion does not allocate or copy memory.

impl<W> From<IntoInnerError<W>> for Error

pub fn from(iie: IntoInnerError<W>) -> Error

impl From<ErrorKind> for Error

Intended for use for errors not exposed to the user, where allocating onto the heap (for normal construction via Error::new) is too costly.

pub fn from(kind: ErrorKind) -> Error

Converts an ErrorKind into an Error.

This conversion allocates a new error with a simple representation of error kind.

Examples

use std::io::{Error, ErrorKind};

let not_found = ErrorKind::NotFound;
let error = Error::from(not_found);
assert_eq!("entity not found", format!("{}", error));

impl<T> From<SendError<T>> for TrySendError<T>

pub fn from(err: SendError<T>) -> TrySendError<T>

Converts a SendError<T> into a TrySendError<T>.

This conversion always returns a TrySendError::Disconnected containing the data in the SendError<T>.

No data is allocated on the heap.

impl<T> From<T> for SyncOnceCell<T>

pub fn from(value: T) -> SyncOnceCell<T>

impl From<CString> for Rc<CStr>

pub fn from(s: CString) -> Rc<CStr>

Converts a CString into a Rc<CStr> without copying or allocating.

impl From<PathBuf> for Rc<Path>

pub fn from(s: PathBuf) -> Rc<Path>

Converts a PathBuf into an Rc by moving the PathBuf data into a new Rc buffer.

impl From<SocketAddrV4> for SocketAddr

pub fn from(sock4: SocketAddrV4) -> SocketAddr

Converts a SocketAddrV4 into a SocketAddr::V4.

impl<'a> From<&'a CStr> for Cow<'a, CStr>

pub fn from(s: &'a CStr) -> Cow<'a, CStr>

impl<'_> From<&'_ OsStr> for Rc<OsStr>

pub fn from(s: &OsStr) -> Rc<OsStr>

impl From<[u8; 16]> for Ipv6Addr

pub fn from(octets: [u8; 16]) -> Ipv6Addr

Creates an Ipv6Addr from a sixteen element byte array.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
    17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
    Ipv6Addr::new(
        0x1918, 0x1716,
        0x1514, 0x1312,
        0x1110, 0x0f0e,
        0x0d0c, 0x0b0a
    ),
    addr
);

impl<'a> From<Cow<'a, CStr>> for CString

pub fn from(s: Cow<'a, CStr>) -> CString

impl<'a> From<&'a CString> for Cow<'a, CStr>

pub fn from(s: &'a CString) -> Cow<'a, CStr>

impl From<RecvError> for TryRecvError

pub fn from(err: RecvError) -> TryRecvError

Converts a RecvError into a TryRecvError.

This conversion always returns TryRecvError::Disconnected.

No data is allocated on the heap.

impl From<Ipv4Addr> for IpAddr

pub fn from(ipv4: Ipv4Addr) -> IpAddr

Copies this address to a new IpAddr::V4.

Examples

use std::net::{IpAddr, Ipv4Addr};

let addr = Ipv4Addr::new(127, 0, 0, 1);

assert_eq!(
    IpAddr::V4(addr),
    IpAddr::from(addr)
)

impl From<u32> for Ipv4Addr

pub fn from(ip: u32) -> Ipv4Addr

Converts a host byte order u32 into an Ipv4Addr.

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::from(0xcafebabe);
assert_eq!(Ipv4Addr::new(0xca, 0xfe, 0xba, 0xbe), addr);

impl From<ChildStdout> for Stdio

pub fn from(child: ChildStdout) -> Stdio

Converts a ChildStdout into a Stdio

Examples

ChildStdout will be converted to Stdio using Stdio::from under the hood.

use std::process::{Command, Stdio};

let hello = Command::new("echo")
    .arg("Hello, world!")
    .stdout(Stdio::piped())
    .spawn()
    .expect("failed echo command");

let reverse = Command::new("rev")
    .stdin(hello.stdout.unwrap())  // Converted into a Stdio here
    .output()
    .expect("failed reverse command");

assert_eq!(reverse.stdout, b"!dlrow ,olleH\n");

impl From<Box<Path>> for PathBuf

pub fn from(boxed: Box<Path>) -> PathBuf

Converts a Box<Path> into a PathBuf

This conversion does not allocate or copy memory.

impl From<u128> for Ipv6Addr

pub fn from(ip: u128) -> Ipv6Addr

Convert a host byte order u128 into an Ipv6Addr.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from(0x102030405060708090A0B0C0D0E0F00D_u128);
assert_eq!(
    Ipv6Addr::new(
        0x1020, 0x3040, 0x5060, 0x7080,
        0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
    ),
    addr);

impl<'a> From<PathBuf> for Cow<'a, Path>

pub fn from(s: PathBuf) -> Cow<'a, Path>

impl From<RecvError> for RecvTimeoutError

pub fn from(err: RecvError) -> RecvTimeoutError

Converts a RecvError into a RecvTimeoutError.

This conversion always returns RecvTimeoutError::Disconnected.

No data is allocated on the heap.

impl From<ChildStdin> for Stdio

pub fn from(child: ChildStdin) -> Stdio

Converts a ChildStdin into a Stdio

Examples

ChildStdin will be converted to Stdio using Stdio::from under the hood.

use std::process::{Command, Stdio};

let reverse = Command::new("rev")
    .stdin(Stdio::piped())
    .spawn()
    .expect("failed reverse command");

let _echo = Command::new("echo")
    .arg("Hello, world!")
    .stdout(reverse.stdin.unwrap()) // Converted into a Stdio here
    .output()
    .expect("failed echo command");

// "!dlrow ,olleH" echoed to console

impl From<Ipv6Addr> for IpAddr

pub fn from(ipv6: Ipv6Addr) -> IpAddr

Copies this address to a new IpAddr::V6.

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

assert_eq!(
    IpAddr::V6(addr),
    IpAddr::from(addr)
);

impl From<OsString> for PathBuf

pub fn from(s: OsString) -> PathBuf

Converts a OsString into a PathBuf

This conversion does not allocate or copy memory.

impl From<File> for Stdio

pub fn from(file: File) -> Stdio

Converts a File into a Stdio

Examples

File will be converted to Stdio using Stdio::from under the hood.

use std::fs::File;
use std::process::Command;

// With the `foo.txt` file containing `Hello, world!"
let file = File::open("foo.txt").unwrap();

let reverse = Command::new("rev")
    .stdin(file)  // Implicit File conversion into a Stdio
    .output()
    .expect("failed reverse command");

assert_eq!(reverse.stdout, b"!dlrow ,olleH");

impl From<NonZeroU8> for NonZeroU128

Converts NonZeroU8 to NonZeroU128 losslessly.

pub fn from(small: NonZeroU8) -> NonZeroU128

impl From<NonZeroU64> for NonZeroI128

Converts NonZeroU64 to NonZeroI128 losslessly.

pub fn from(small: NonZeroU64) -> NonZeroI128

impl From<i32> for i128

Converts i32 to i128 losslessly.

pub fn from(small: i32) -> i128

impl From<NonZeroI16> for NonZeroI64

Converts NonZeroI16 to NonZeroI64 losslessly.

pub fn from(small: NonZeroI16) -> NonZeroI64

impl From<NonZeroI8> for NonZeroI16

Converts NonZeroI8 to NonZeroI16 losslessly.

pub fn from(small: NonZeroI8) -> NonZeroI16

impl From<f32> for f64

Converts f32 to f64 losslessly.

pub fn from(small: f32) -> f64

impl From<bool> for u16

Converts a bool to a u16. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u16::from(true), 1);
assert_eq!(u16::from(false), 0);

pub fn from(small: bool) -> u16

impl From<i8> for AtomicI8

pub fn from(v: i8) -> AtomicI8

Converts an i8 into an AtomicI8.

impl From<bool> for i8

Converts a bool to a i8. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i8::from(true), 1);
assert_eq!(i8::from(false), 0);

pub fn from(small: bool) -> i8

impl From<NonZeroIsize> for isize

pub fn from(nonzero: NonZeroIsize) -> isize

Converts a NonZeroIsize into an isize

impl From<NonZeroU16> for NonZeroI128

Converts NonZeroU16 to NonZeroI128 losslessly.

pub fn from(small: NonZeroU16) -> NonZeroI128

impl From<i32> for f64

Converts i32 to f64 losslessly.

pub fn from(small: i32) -> f64

impl From<isize> for AtomicIsize

pub fn from(v: isize) -> AtomicIsize

Converts an isize into an AtomicIsize.

impl<T> From<T> for UnsafeCell<T>

pub fn from(t: T) -> UnsafeCell<T>

impl From<bool> for i16

Converts a bool to a i16. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i16::from(true), 1);
assert_eq!(i16::from(false), 0);

pub fn from(small: bool) -> i16

impl From<i64> for AtomicI64

pub fn from(v: i64) -> AtomicI64

Converts an i64 into an AtomicI64.

impl From<bool> for i64

Converts a bool to a i64. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i64::from(true), 1);
assert_eq!(i64::from(false), 0);

pub fn from(small: bool) -> i64

impl From<u16> for u64

Converts u16 to u64 losslessly.

pub fn from(small: u16) -> u64

impl From<i32> for AtomicI32

pub fn from(v: i32) -> AtomicI32

Converts an i32 into an AtomicI32.

impl From<u16> for i32

Converts u16 to i32 losslessly.

pub fn from(small: u16) -> i32

impl From<u8> for usize

Converts u8 to usize losslessly.

pub fn from(small: u8) -> usize

impl From<u16> for f64

Converts u16 to f64 losslessly.

pub fn from(small: u16) -> f64

impl From<u64> for i128

Converts u64 to i128 losslessly.

pub fn from(small: u64) -> i128

impl From<bool> for usize

Converts a bool to a usize. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(usize::from(true), 1);
assert_eq!(usize::from(false), 0);

pub fn from(small: bool) -> usize

impl From<NonZeroU32> for NonZeroI128

Converts NonZeroU32 to NonZeroI128 losslessly.

pub fn from(small: NonZeroU32) -> NonZeroI128

impl From<NonZeroU16> for NonZeroU128

Converts NonZeroU16 to NonZeroU128 losslessly.

pub fn from(small: NonZeroU16) -> NonZeroU128

impl From<u16> for usize

Converts u16 to usize losslessly.

pub fn from(small: u16) -> usize

impl From<NonZeroI8> for NonZeroIsize

Converts NonZeroI8 to NonZeroIsize losslessly.

pub fn from(small: NonZeroI8) -> NonZeroIsize

impl From<u8> for f32

Converts u8 to f32 losslessly.

pub fn from(small: u8) -> f32

impl From<u32> for f64

Converts u32 to f64 losslessly.

pub fn from(small: u32) -> f64

impl From<u8> for char

Maps a byte in 0x00..=0xFF to a char whose code point has the same value, in U+0000..=U+00FF.

Unicode is designed such that this effectively decodes bytes with the character encoding that IANA calls ISO-8859-1. This encoding is compatible with ASCII.

Note that this is different from ISO/IEC 8859-1 a.k.a. ISO 8859-1 (with one less hyphen), which leaves some "blanks", byte values that are not assigned to any character. ISO-8859-1 (the IANA one) assigns them to the C0 and C1 control codes.

Note that this is also different from Windows-1252 a.k.a. code page 1252, which is a superset ISO/IEC 8859-1 that assigns some (not all!) blanks to punctuation and various Latin characters.

To confuse things further, on the Web ascii, iso-8859-1, and windows-1252 are all aliases for a superset of Windows-1252 that fills the remaining blanks with corresponding C0 and C1 control codes.

pub fn from(i: u8) -> char

Converts a u8 into a char.

Examples

use std::mem;

let u = 32 as u8;
let c = char::from(u);
assert!(4 == mem::size_of_val(&c))

impl From<NonZeroU128> for u128

pub fn from(nonzero: NonZeroU128) -> u128

Converts a NonZeroU128 into an u128

impl From<u8> for i64

Converts u8 to i64 losslessly.

pub fn from(small: u8) -> i64

impl From<u32> for i64

Converts u32 to i64 losslessly.

pub fn from(small: u32) -> i64

impl From<u64> for u128

Converts u64 to u128 losslessly.

pub fn from(small: u64) -> u128

impl<T> From<T> for RefCell<T>

pub fn from(t: T) -> RefCell<T>

impl From<NonZeroI16> for NonZeroIsize

Converts NonZeroI16 to NonZeroIsize losslessly.

pub fn from(small: NonZeroI16) -> NonZeroIsize

impl From<NonZeroU8> for NonZeroI128

Converts NonZeroU8 to NonZeroI128 losslessly.

pub fn from(small: NonZeroU8) -> NonZeroI128

impl From<NonZeroU64> for NonZeroU128

Converts NonZeroU64 to NonZeroU128 losslessly.

pub fn from(small: NonZeroU64) -> NonZeroU128

impl From<NonZeroI16> for NonZeroI128

Converts NonZeroI16 to NonZeroI128 losslessly.

pub fn from(small: NonZeroI16) -> NonZeroI128

impl From<NonZeroI8> for i8

pub fn from(nonzero: NonZeroI8) -> i8

Converts a NonZeroI8 into an i8

impl From<u8> for AtomicU8

pub fn from(v: u8) -> AtomicU8

Converts an u8 into an AtomicU8.

impl From<bool> for u8

Converts a bool to a u8. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u8::from(true), 1);
assert_eq!(u8::from(false), 0);

pub fn from(small: bool) -> u8

impl From<u8> for i16

Converts u8 to i16 losslessly.

pub fn from(small: u8) -> i16

impl From<u64> for AtomicU64

pub fn from(v: u64) -> AtomicU64

Converts an u64 into an AtomicU64.

impl From<i16> for AtomicI16

pub fn from(v: i16) -> AtomicI16

Converts an i16 into an AtomicI16.

impl From<NonZeroU64> for u64

pub fn from(nonzero: NonZeroU64) -> u64

Converts a NonZeroU64 into an u64

impl From<!> for TryFromIntError

pub fn from(never: !) -> TryFromIntError

impl From<u8> for i32

Converts u8 to i32 losslessly.

pub fn from(small: u8) -> i32

impl<T> From<T> for OnceCell<T>

pub fn from(value: T) -> OnceCell<T>

impl From<u8> for f64

Converts u8 to f64 losslessly.

pub fn from(small: u8) -> f64

impl From<u16> for u32

Converts u16 to u32 losslessly.

pub fn from(small: u16) -> u32

impl From<u8> for u64

Converts u8 to u64 losslessly.

pub fn from(small: u8) -> u64

impl From<NonZeroI64> for NonZeroI128

Converts NonZeroI64 to NonZeroI128 losslessly.

pub fn from(small: NonZeroI64) -> NonZeroI128

impl From<NonZeroU8> for NonZeroUsize

Converts NonZeroU8 to NonZeroUsize losslessly.

pub fn from(small: NonZeroU8) -> NonZeroUsize

impl<T> From<T> for Poll<T>

pub fn from(t: T) -> Poll<T>

Convert to a Ready variant.

Example

assert_eq!(Poll::from(true), Poll::Ready(true));

impl<'_, T> From<&'_ T> for NonNull<T> where
    T: ?Sized, 

pub fn from(reference: &T) -> NonNull<T>

impl From<i16> for i32

Converts i16 to i32 losslessly.

pub fn from(small: i16) -> i32

impl From<NonZeroI32> for NonZeroI64

Converts NonZeroI32 to NonZeroI64 losslessly.

pub fn from(small: NonZeroI32) -> NonZeroI64

impl From<!> for Infallible

pub fn from(x: !) -> Infallible

impl From<NonZeroU8> for NonZeroI16

Converts NonZeroU8 to NonZeroI16 losslessly.

pub fn from(small: NonZeroU8) -> NonZeroI16

impl From<Infallible> for TryFromIntError

pub fn from(x: Infallible) -> TryFromIntError

impl From<NonZeroU8> for NonZeroU64

Converts NonZeroU8 to NonZeroU64 losslessly.

pub fn from(small: NonZeroU8) -> NonZeroU64

impl<T> From<Unique<T>> for NonNull<T> where
    T: ?Sized, 

pub fn from(unique: Unique<T>) -> NonNull<T>

impl From<NonZeroI8> for NonZeroI32

Converts NonZeroI8 to NonZeroI32 losslessly.

pub fn from(small: NonZeroI8) -> NonZeroI32

impl From<u8> for u32

Converts u8 to u32 losslessly.

pub fn from(small: u8) -> u32

impl From<bool> for AtomicBool

pub fn from(b: bool) -> AtomicBool

Converts a bool into an AtomicBool.

Examples

use std::sync::atomic::AtomicBool;
let atomic_bool = AtomicBool::from(true);
assert_eq!(format!("{:?}", atomic_bool), "true")

impl From<bool> for u32

Converts a bool to a u32. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u32::from(true), 1);
assert_eq!(u32::from(false), 0);

pub fn from(small: bool) -> u32

impl From<NonZeroU8> for u8

pub fn from(nonzero: NonZeroU8) -> u8

Converts a NonZeroU8 into an u8

impl From<i16> for isize

Converts i16 to isize losslessly.

pub fn from(small: i16) -> isize

impl From<NonZeroI8> for NonZeroI64

Converts NonZeroI8 to NonZeroI64 losslessly.

pub fn from(small: NonZeroI8) -> NonZeroI64

impl From<bool> for i32

Converts a bool to a i32. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i32::from(true), 1);
assert_eq!(i32::from(false), 0);

pub fn from(small: bool) -> i32

impl<T> From<T> for Cell<T>

pub fn from(t: T) -> Cell<T>

impl From<NonZeroU8> for NonZeroU32

Converts NonZeroU8 to NonZeroU32 losslessly.

pub fn from(small: NonZeroU8) -> NonZeroU32

impl From<NonZeroU8> for NonZeroI32

Converts NonZeroU8 to NonZeroI32 losslessly.

pub fn from(small: NonZeroU8) -> NonZeroI32

impl<'_, T> From<&'_ mut T> for NonNull<T> where
    T: ?Sized, 

pub fn from(reference: &mut T) -> NonNull<T>

impl From<NonZeroI16> for NonZeroI32

Converts NonZeroI16 to NonZeroI32 losslessly.

pub fn from(small: NonZeroI16) -> NonZeroI32

impl From<u32> for i128

Converts u32 to i128 losslessly.

pub fn from(small: u32) -> i128

impl From<bool> for u64

Converts a bool to a u64. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u64::from(true), 1);
assert_eq!(u64::from(false), 0);

pub fn from(small: bool) -> u64

impl From<NonZeroI64> for i64

pub fn from(nonzero: NonZeroI64) -> i64

Converts a NonZeroI64 into an i64

impl From<NonZeroI8> for NonZeroI128

Converts NonZeroI8 to NonZeroI128 losslessly.

pub fn from(small: NonZeroI8) -> NonZeroI128

impl From<i8> for i32

Converts i8 to i32 losslessly.

pub fn from(small: i8) -> i32

impl From<NonZeroU32> for NonZeroU64

Converts NonZeroU32 to NonZeroU64 losslessly.

pub fn from(small: NonZeroU32) -> NonZeroU64

impl From<NonZeroU32> for NonZeroI64

Converts NonZeroU32 to NonZeroI64 losslessly.

pub fn from(small: NonZeroU32) -> NonZeroI64

impl From<NonZeroI16> for i16

pub fn from(nonzero: NonZeroI16) -> i16

Converts a NonZeroI16 into an i16

impl From<NonZeroU16> for NonZeroI32

Converts NonZeroU16 to NonZeroI32 losslessly.

pub fn from(small: NonZeroU16) -> NonZeroI32

impl From<u8> for isize

Converts u8 to isize losslessly.

pub fn from(small: u8) -> isize

impl From<NonZeroU16> for NonZeroUsize

Converts NonZeroU16 to NonZeroUsize losslessly.

pub fn from(small: NonZeroU16) -> NonZeroUsize

impl From<NonZeroU8> for NonZeroU16

Converts NonZeroU8 to NonZeroU16 losslessly.

pub fn from(small: NonZeroU8) -> NonZeroU16

impl From<NonZeroU32> for NonZeroU128

Converts NonZeroU32 to NonZeroU128 losslessly.

pub fn from(small: NonZeroU32) -> NonZeroU128

impl From<NonZeroUsize> for usize

pub fn from(nonzero: NonZeroUsize) -> usize

Converts a NonZeroUsize into an usize

impl From<Infallible> for TryFromSliceError

pub fn from(x: Infallible) -> TryFromSliceError

impl From<u16> for i64

Converts u16 to i64 losslessly.

pub fn from(small: u16) -> i64

impl From<i16> for i128

Converts i16 to i128 losslessly.

pub fn from(small: i16) -> i128

impl From<u16> for i128

Converts u16 to i128 losslessly.

pub fn from(small: u16) -> i128

impl From<u8> for i128

Converts u8 to i128 losslessly.

pub fn from(small: u8) -> i128

impl From<bool> for isize

Converts a bool to a isize. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(isize::from(true), 1);
assert_eq!(isize::from(false), 0);

pub fn from(small: bool) -> isize

impl From<usize> for AtomicUsize

pub fn from(v: usize) -> AtomicUsize

Converts an usize into an AtomicUsize.

impl From<i8> for f64

Converts i8 to f64 losslessly.

pub fn from(small: i8) -> f64

impl From<u8> for u128

Converts u8 to u128 losslessly.

pub fn from(small: u8) -> u128

impl From<NonZeroU16> for NonZeroI64

Converts NonZeroU16 to NonZeroI64 losslessly.

pub fn from(small: NonZeroU16) -> NonZeroI64

impl From<i8> for i64

Converts i8 to i64 losslessly.

pub fn from(small: i8) -> i64

impl From<NonZeroI32> for i32

pub fn from(nonzero: NonZeroI32) -> i32

Converts a NonZeroI32 into an i32

impl From<i16> for i64

Converts i16 to i64 losslessly.

pub fn from(small: i16) -> i64

impl From<i8> for f32

Converts i8 to f32 losslessly.

pub fn from(small: i8) -> f32

impl From<NonZeroU8> for NonZeroIsize

Converts NonZeroU8 to NonZeroIsize losslessly.

pub fn from(small: NonZeroU8) -> NonZeroIsize

impl From<NonZeroU32> for u32

pub fn from(nonzero: NonZeroU32) -> u32

Converts a NonZeroU32 into an u32

impl From<i64> for i128

Converts i64 to i128 losslessly.

pub fn from(small: i64) -> i128

impl From<NonZeroI128> for i128

pub fn from(nonzero: NonZeroI128) -> i128

Converts a NonZeroI128 into an i128

impl From<NonZeroI32> for NonZeroI128

Converts NonZeroI32 to NonZeroI128 losslessly.

pub fn from(small: NonZeroI32) -> NonZeroI128

impl From<NonZeroU8> for NonZeroI64

Converts NonZeroU8 to NonZeroI64 losslessly.

pub fn from(small: NonZeroU8) -> NonZeroI64

impl From<NonZeroU16> for NonZeroU32

Converts NonZeroU16 to NonZeroU32 losslessly.

pub fn from(small: NonZeroU16) -> NonZeroU32

impl From<bool> for u128

Converts a bool to a u128. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u128::from(true), 1);
assert_eq!(u128::from(false), 0);

pub fn from(small: bool) -> u128

impl From<u16> for AtomicU16

pub fn from(v: u16) -> AtomicU16

Converts an u16 into an AtomicU16.

impl From<i8> for i16

Converts i8 to i16 losslessly.

pub fn from(small: i8) -> i16

impl From<u32> for u64

Converts u32 to u64 losslessly.

pub fn from(small: u32) -> u64

impl From<i8> for i128

Converts i8 to i128 losslessly.

pub fn from(small: i8) -> i128

impl From<NonZeroU16> for u16

pub fn from(nonzero: NonZeroU16) -> u16

Converts a NonZeroU16 into an u16

impl From<i16> for f32

Converts i16 to f32 losslessly.

pub fn from(small: i16) -> f32

impl From<u32> for u128

Converts u32 to u128 losslessly.

pub fn from(small: u32) -> u128

impl From<u16> for u128

Converts u16 to u128 losslessly.

pub fn from(small: u16) -> u128

impl From<u32> for AtomicU32

pub fn from(v: u32) -> AtomicU32

Converts an u32 into an AtomicU32.

impl<T> From<*mut T> for AtomicPtr<T>

pub fn from(p: *mut T) -> AtomicPtr<T>

impl From<i8> for isize

Converts i8 to isize losslessly.

pub fn from(small: i8) -> isize

impl From<u16> for f32

Converts u16 to f32 losslessly.

pub fn from(small: u16) -> f32

impl From<u8> for u16

Converts u8 to u16 losslessly.

pub fn from(small: u8) -> u16

impl From<char> for u32

pub fn from(c: char) -> u32

Converts a char into a u32.

Examples

use std::mem;

let c = 'c';
let u = u32::from(c);
assert!(4 == mem::size_of_val(&u))

impl From<i16> for f64

Converts i16 to f64 losslessly.

pub fn from(small: i16) -> f64

impl From<i32> for i64

Converts i32 to i64 losslessly.

pub fn from(small: i32) -> i64

impl From<bool> for i128

Converts a bool to a i128. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i128::from(true), 1);
assert_eq!(i128::from(false), 0);

pub fn from(small: bool) -> i128

impl From<NonZeroU16> for NonZeroU64

Converts NonZeroU16 to NonZeroU64 losslessly.

pub fn from(small: NonZeroU16) -> NonZeroU64

impl<T> From<Vec<T>> for Rc<[T]>

pub fn from(v: Vec<T>) -> Rc<[T]>

impl<W> From<Arc<W>> for RawWaker where
    W: 'static + Wake + Send + Sync, 

pub fn from(waker: Arc<W>) -> RawWaker

impl<'a, B> From<Cow<'a, B>> for Rc<B> where
    B: ToOwned + ?Sized,
    Rc<B>: From<&'a B>,
    Rc<B>: From<<B as ToOwned>::Owned>, 

pub fn from(cow: Cow<'a, B>) -> Rc<B>

impl<'a, T> From<&'a Vec<T>> for Cow<'a, [T]> where
    T: Clone, 

pub fn from(v: &'a Vec<T>) -> Cow<'a, [T]>

impl<'_> From<&'_ String> for String

pub fn from(s: &String) -> String

impl<T> From<Box<T>> for Rc<T> where
    T: ?Sized, 

pub fn from(v: Box<T>) -> Rc<T>

impl From<String> for Rc<str>

pub fn from(v: String) -> Rc<str>

impl<'a> From<&'a str> for Cow<'a, str>

pub fn from(s: &'a str) -> Cow<'a, str>

impl<T> From<Box<T>> for Pin<Box<T>> where
    T: ?Sized, 

pub fn from(boxed: Box<T>) -> Pin<Box<T>>

Converts a Box<T> into a Pin<Box<T>>

This conversion does not allocate on the heap and happens in place.

impl<W> From<Arc<W>> for Waker where
    W: 'static + Wake + Send + Sync, 

pub fn from(waker: Arc<W>) -> Waker

impl<'_> From<&'_ mut str> for String

pub fn from(s: &mut str) -> String

Converts a &mut str into a String.

The result is allocated on the heap.

impl<'_, T> From<&'_ [T]> for Rc<[T]> where
    T: Clone, 

pub fn from(v: &[T]) -> Rc<[T]>

impl<'_> From<&'_ str> for Rc<str>

pub fn from(v: &str) -> Rc<str>

impl<'a> From<&'a String> for Cow<'a, str>

pub fn from(s: &'a String) -> Cow<'a, str>

impl From<char> for String

pub fn from(c: char) -> String

impl<T> From<Vec<T>> for BinaryHeap<T> where
    T: Ord, 

pub fn from(vec: Vec<T>) -> BinaryHeap<T>

Converts a Vec<T> into a BinaryHeap<T>.

This conversion happens in-place, and has O(n) time complexity.

impl<'a, T> From<&'a [T]> for Cow<'a, [T]> where
    T: Clone, 

pub fn from(s: &'a [T]) -> Cow<'a, [T]>

impl<'a, T> From<Vec<T>> for Cow<'a, [T]> where
    T: Clone, 

pub fn from(v: Vec<T>) -> Cow<'a, [T]>

impl<'a> From<String> for Cow<'a, str>

pub fn from(s: String) -> Cow<'a, str>

impl<'_> From<&'_ str> for String

pub fn from(s: &str) -> String

impl<'a> From<Cow<'a, str>> for String

pub fn from(s: Cow<'a, str>) -> String

impl<T> From<Vec<T>> for VecDeque<T>

pub fn from(other: Vec<T>) -> VecDeque<T>

Turn a Vec<T> into a VecDeque<T>.

This avoids reallocating where possible, but the conditions for that are strict, and subject to change, and so shouldn't be relied upon unless the Vec<T> came from From<VecDeque<T>> and hasn't been reallocated.

impl From<LayoutErr> for TryReserveError

pub fn from(LayoutErr) -> TryReserveError

impl<T> From<T> for Rc<T>

pub fn from(t: T) -> Rc<T>

impl From<Box<str>> for String

pub fn from(s: Box<str>) -> String

Converts the given boxed str slice to a String. It is notable that the str slice is owned.

Examples

Basic usage:

let s1: String = String::from("hello world");
let s2: Box<str> = s1.into_boxed_str();
let s3: String = String::from(s2);

assert_eq!("hello world", s3)

impl<T> From<HashSet<T, RandomState>> for AHashSet<T, RandomState>

pub fn from(item: HashSet<T, RandomState>) -> AHashSet<T, RandomState>

impl<K, V> From<HashMap<K, V, RandomState>> for AHashMap<K, V, RandomState>

pub fn from(item: HashMap<K, V, RandomState>) -> AHashMap<K, V, RandomState>

impl From<NonZeroU32> for Error

pub fn from(code: NonZeroU32) -> Error

impl<T> From<T> for CachePadded<T>

pub fn from(t: T) -> CachePadded<T>

impl<R, T> From<T> for Mutex<R, T> where
    R: RawMutex, 

pub fn from(t: T) -> Mutex<R, T>

impl<R, T> From<T> for RwLock<R, T> where
    R: RawRwLock, 

pub fn from(t: T) -> RwLock<R, T>

impl<R, G, T> From<T> for ReentrantMutex<R, G, T> where
    G: GetThreadId,
    R: RawMutex, 

pub fn from(t: T) -> ReentrantMutex<R, G, T>

impl<A> From<A> for SmallVec<A> where
    A: Array, 

pub fn from(array: A) -> SmallVec<A>

impl<'a, A> From<&'a [<A as Array>::Item]> for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Clone, 

pub fn from(slice: &'a [<A as Array>::Item]) -> SmallVec<A>

impl<A> From<Vec<<A as Array>::Item>> for SmallVec<A> where
    A: Array, 

pub fn from(vec: Vec<<A as Array>::Item>) -> SmallVec<A>

impl From<LayoutErr> for CollectionAllocErr

pub fn from(LayoutErr) -> CollectionAllocErr

impl<X> From<RangeInclusive<X>> for Uniform<X> where
    X: SampleUniform, 

pub fn from(r: RangeInclusive<X>) -> Uniform<X>

impl<X> From<Range<X>> for Uniform<X> where
    X: SampleUniform, 

pub fn from(r: Range<X>) -> Uniform<X>

impl From<Vec<u32>> for IndexVec

pub fn from(v: Vec<u32>) -> IndexVec

impl From<Vec<usize>> for IndexVec

pub fn from(v: Vec<usize>) -> IndexVec

impl From<NonZeroU32> for Error

pub fn from(code: NonZeroU32) -> Error

impl From<Error> for Error

pub fn from(error: Error) -> Error

impl From<Error> for Error

pub fn from(error: Error) -> Error

impl From<NonZeroU32> for Error

pub fn from(code: NonZeroU32) -> Error

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl From<ChaCha20Core> for ChaCha20Rng

pub fn from(core: ChaCha20Core) -> ChaCha20Rng

impl From<ChaCha12Core> for ChaCha12Rng

pub fn from(core: ChaCha12Core) -> ChaCha12Rng

impl From<ChaCha8Core> for ChaCha8Rng

pub fn from(core: ChaCha8Core) -> ChaCha8Rng

impl<W> From<x4<W>> for vec512_storage where
    W: Copy,
    vec128_storage: From<W>, 

pub fn from(x: x4<W>) -> vec512_storage

impl<NI> From<u32x4x4_avx2<NI>> for vec512_storage

pub fn from(x: u32x4x4_avx2<NI>) -> vec512_storage

impl<W, G> From<x2<W, G>> for vec256_storage where
    W: Copy,
    vec128_storage: From<W>, 

pub fn from(x: x2<W, G>) -> vec256_storage

impl<S3, S4, NI> From<u128x1_sse2<S3, S4, NI>> for vec128_storage

pub fn from(x: u128x1_sse2<S3, S4, NI>) -> vec128_storage

impl<S3, S4, NI> From<u32x4_sse2<S3, S4, NI>> for vec128_storage

pub fn from(x: u32x4_sse2<S3, S4, NI>) -> vec128_storage

impl<S3, S4, NI> From<u64x2_sse2<S3, S4, NI>> for vec128_storage

pub fn from(x: u64x2_sse2<S3, S4, NI>) -> vec128_storage

impl<E> From<E> for Error where
    E: Error + Send + Sync + 'static, 

pub fn from(error: E) -> Error

impl<T> From<SendError<T>> for TrySendError<T>

pub fn from(err: SendError<T>) -> TrySendError<T>

impl From<RecvError> for TryRecvError

pub fn from(err: RecvError) -> TryRecvError

impl<T> From<SendError<T>> for SendTimeoutError<T>

pub fn from(err: SendError<T>) -> SendTimeoutError<T>

impl From<RecvError> for RecvTimeoutError

pub fn from(err: RecvError) -> RecvTimeoutError

impl<T> From<T> for CachePadded<T>

pub fn from(t: T) -> CachePadded<T>

impl<T> From<T> for ShardedLock<T>

pub fn from(t: T) -> ShardedLock<T>

impl From<Uuid> for Simple

pub fn from(f: Uuid) -> Simple

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl<'a> From<&'a Uuid> for SimpleRef<'a>

pub fn from(f: &'a Uuid) -> SimpleRef<'a>

impl From<Uuid> for Hyphenated

pub fn from(f: Uuid) -> Hyphenated

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl<'a> From<&'a Uuid> for HyphenatedRef<'a>

pub fn from(f: &'a Uuid) -> HyphenatedRef<'a>

impl From<Uuid> for Urn

pub fn from(f: Uuid) -> Urn

impl<'a> From<&'a Uuid> for UrnRef<'a>

pub fn from(f: &'a Uuid) -> UrnRef<'a>

impl From<Quat> for [f32; 4]

pub fn from(q: Quat) -> [f32; 4]

impl From<Vec3AMask> for [u32; 3]

pub fn from(mask: Vec3AMask) -> [u32; 3]

impl From<Vec4> for __m128

pub fn from(t: Vec4) -> __m128

impl From<Vec3A> for (f32, f32, f32)

pub fn from(v: Vec3A) -> (f32, f32, f32)

impl From<Vec2Mask> for [u32; 2]

pub fn from(mask: Vec2Mask) -> [u32; 2]

impl From<Vec4> for [f32; 4]

pub fn from(v: Vec4) -> [f32; 4]

impl From<Vec3> for [f32; 3]

pub fn from(v: Vec3) -> [f32; 3]

impl From<Vec3AMask> for __m128

pub fn from(t: Vec3AMask) -> __m128

impl From<Vec3A> for __m128

pub fn from(t: Vec3A) -> __m128

impl From<Vec4Mask> for [u32; 4]

pub fn from(mask: Vec4Mask) -> [u32; 4]

impl From<Quat> for __m128

pub fn from(q: Quat) -> __m128

impl From<Quat> for (f32, f32, f32, f32)

pub fn from(q: Quat) -> (f32, f32, f32, f32)

impl From<Vec4Mask> for __m128

pub fn from(t: Vec4Mask) -> __m128

impl From<Vec3A> for [f32; 3]

pub fn from(v: Vec3A) -> [f32; 3]

impl From<Vec2> for [f32; 2]

pub fn from(v: Vec2) -> [f32; 2]

impl From<Vec3> for (f32, f32, f32)

pub fn from(v: Vec3) -> (f32, f32, f32)

impl From<Vec2> for (f32, f32)

pub fn from(v: Vec2) -> (f32, f32)

impl From<Vec3Mask> for [u32; 3]

pub fn from(mask: Vec3Mask) -> [u32; 3]

impl From<Vec4> for (f32, f32, f32, f32)

pub fn from(v: Vec4) -> (f32, f32, f32, f32)

impl From<f64> for Number

pub fn from(f: f64) -> Number

impl From<u64> for Number

pub fn from(i: u64) -> Number

impl From<FromUtf8Error> for ErrorCode

pub fn from(e: FromUtf8Error) -> ErrorCode

impl From<Error> for Error

pub fn from(e: Error) -> Error

impl From<Utf8Error> for Error

pub fn from(e: Utf8Error) -> Error

impl From<i32> for Number

pub fn from(i: i32) -> Number

impl From<Utf8Error> for ErrorCode

pub fn from(e: Utf8Error) -> ErrorCode

impl From<i64> for Number

pub fn from(i: i64) -> Number

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl<T> From<SendError<T>> for Error

pub fn from(err: SendError<T>) -> Error

impl From<RecvError> for Error

pub fn from(err: RecvError) -> Error

impl<T> From<SendError<T>> for Error

pub fn from(err: SendError<T>) -> Error

impl<T> From<PoisonError<T>> for Error

pub fn from(err: PoisonError<T>) -> Error

impl From<Error> for Error

pub fn from(walk_err: Error) -> Error

Convert the Error to an io::Error, preserving the original Error as the "inner error". Note that this also makes the display of the error include the context.

This is different from into_io_error which returns the original io::Error.

impl From<SystemTime> for FileTime

pub fn from(time: SystemTime) -> FileTime

impl From<Token> for usize

pub fn from(val: Token) -> usize

impl From<Ready> for UnixReady

pub fn from(src: Ready) -> UnixReady

impl From<ReadinessState> for usize

pub fn from(src: ReadinessState) -> usize

impl From<UnixReady> for Ready

pub fn from(src: UnixReady) -> Ready

impl From<usize> for Token

pub fn from(val: usize) -> Token

impl<T> From<Error> for TrySendError<T>

pub fn from(src: Error) -> TrySendError<T>

impl<T> From<SendError<T>> for SendError<T>

pub fn from(src: SendError<T>) -> SendError<T>

impl<T> From<TrySendError<T>> for TrySendError<T>

pub fn from(src: TrySendError<T>) -> TrySendError<T>

impl<T> From<Error> for SendError<T>

pub fn from(src: Error) -> SendError<T>

impl<T> From<SendError<T>> for TrySendError<T>

pub fn from(src: SendError<T>) -> TrySendError<T>

impl<'a, T, L> From<T> for Labels where
    L: Into<Cow<'static, str>>,
    T: IntoIterator<Item = L>, 

pub fn from(value: T) -> Labels

impl<'_> From<&'_ TouchInput> for Touch

pub fn from(input: &TouchInput) -> Touch

impl From<PlayStreamError> for StreamError

pub fn from(err: PlayStreamError) -> StreamError

impl From<DecoderError> for PlayError

pub fn from(err: DecoderError) -> PlayError

impl From<DeviceInner> for Device

pub fn from(d: DeviceInner) -> Device

impl From<Host> for Host

pub fn from(h: Host) -> Host

impl From<BackendSpecificError> for DevicesError

pub fn from(source: BackendSpecificError) -> DevicesError

impl From<Device> for Device

pub fn from(h: Device) -> Device

impl From<DevicesInner> for Devices

pub fn from(d: DevicesInner) -> Devices

impl From<Error> for StreamError

pub fn from(err: Error) -> StreamError

impl From<Error> for DevicesError

pub fn from(err: Error) -> DevicesError

impl From<Error> for PauseStreamError

pub fn from(err: Error) -> PauseStreamError

impl From<SupportedStreamConfig> for StreamConfig

pub fn from(conf: SupportedStreamConfig) -> StreamConfig

impl From<Stream> for Stream

pub fn from(h: Stream) -> Stream

impl From<Devices> for Devices

pub fn from(h: Devices) -> Devices

impl From<Error> for BackendSpecificError

pub fn from(err: Error) -> BackendSpecificError

impl From<BackendSpecificError> for PlayStreamError

pub fn from(source: BackendSpecificError) -> PlayStreamError

impl From<BackendSpecificError> for DeviceNameError

pub fn from(source: BackendSpecificError) -> DeviceNameError

impl From<BackendSpecificError> for SupportedStreamConfigsError

pub fn from(source: BackendSpecificError) -> SupportedStreamConfigsError

impl From<BackendSpecificError> for DefaultStreamConfigError

pub fn from(source: BackendSpecificError) -> DefaultStreamConfigError

impl From<Error> for BuildStreamError

pub fn from(err: Error) -> BuildStreamError

impl From<BackendSpecificError> for BuildStreamError

pub fn from(source: BackendSpecificError) -> BuildStreamError

impl From<BackendSpecificError> for StreamError

pub fn from(source: BackendSpecificError) -> StreamError

impl From<StreamInner> for Stream

pub fn from(s: StreamInner) -> Stream

impl From<HostInner> for Host

pub fn from(h: HostInner) -> Host

impl From<BackendSpecificError> for PauseStreamError

pub fn from(source: BackendSpecificError) -> PauseStreamError

impl From<Error> for SupportedStreamConfigsError

pub fn from(err: Error) -> SupportedStreamConfigsError

impl From<Error> for PlayStreamError

pub fn from(err: Error) -> PlayStreamError

impl<'a> From<&'a [ChmapPosition]> for Chmap

pub fn from(a: &'a [ChmapPosition]) -> Chmap

impl From<Error> for Error

pub fn from(Error) -> Error

impl From<timeval> for TimeVal

pub fn from(tv: timeval) -> TimeVal

impl From<ucred> for UnixCredentials

pub fn from(cred: ucred) -> UnixCredentials

impl<'a> From<Vec<AioCb<'a>>> for LioCb<'a>

pub fn from(src: Vec<AioCb<'a>>) -> LioCb<'a>

impl<'a> From<&'a sigevent> for SigEvent

pub fn from(sigevent: &sigevent) -> SigEvent

impl From<Uid> for u32

pub fn from(uid: Uid) -> u32

impl From<Pid> for i32

pub fn from(pid: Pid) -> i32

impl From<Gid> for u32

pub fn from(gid: Gid) -> u32

impl From<u32> for BaudRate

pub fn from(s: u32) -> BaudRate

impl From<Errno> for Error

pub fn from(errno: Errno) -> Error

impl From<Termios> for termios

pub fn from(termios: Termios) -> termios

impl From<termios> for Termios

pub fn from(termios: termios) -> Termios

impl From<FromUtf8Error> for Error

pub fn from(FromUtf8Error) -> Error

impl From<Errno> for Error

pub fn from(err: Errno) -> Error

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl<'a, T> From<&'a [T]> for SliceDeque<T> where
    T: Clone, 

pub fn from(s: &'a [T]) -> SliceDeque<T>

impl<'a, T> From<&'a mut [T]> for SliceDeque<T> where
    T: Clone, 

pub fn from(s: &'a mut [T]) -> SliceDeque<T>

impl From<Error> for GltfError

pub fn from(source: Error) -> GltfError

impl From<DecodeError> for GltfError

pub fn from(source: DecodeError) -> GltfError

impl From<ImageError> for GltfError

pub fn from(source: ImageError) -> GltfError

impl From<AssetIoError> for GltfError

pub fn from(source: AssetIoError) -> GltfError

impl From<Handle<Texture>> for StandardMaterial

pub fn from(texture: Handle<Texture>) -> StandardMaterial

impl From<Color> for StandardMaterial

pub fn from(color: Color) -> StandardMaterial

impl From<Color> for [f32; 4]

pub fn from(color: Color) -> [f32; 4]

impl From<i32> for ReflectOp

pub fn from(raw_op: i32) -> ReflectOp

impl From<i32> for ReflectBuiltIn

pub fn from(raw_built_in: i32) -> ReflectBuiltIn

impl From<Delay> for Duration

pub fn from(delay: Delay) -> Duration

impl<'_> From<&'_ Path> for ImageFormatHint

pub fn from(path: &Path) -> ImageFormatHint

impl From<Error> for ImageError

pub fn from(error: Error) -> ImageError

impl<T> From<[T; 4]> for Bgra<T> where
    T: 'static + Primitive, 

pub fn from(c: [T; 4]) -> Bgra<T>

impl<T> From<[T; 4]> for Rgba<T> where
    T: 'static + Primitive, 

pub fn from(c: [T; 4]) -> Rgba<T>

impl<T> From<[T; 2]> for LumaA<T> where
    T: 'static + Primitive, 

pub fn from(c: [T; 2]) -> LumaA<T>

impl From<Error> for ImageError

pub fn from(err: Error) -> ImageError

impl From<ImageFormatHint> for UnsupportedError

pub fn from(hint: ImageFormatHint) -> UnsupportedError

impl From<ColorType> for ExtendedColorType

pub fn from(c: ColorType) -> ExtendedColorType

impl From<NeuQuant> for NeuQuant

pub fn from(inner: NeuQuant) -> NeuQuant

impl From<ImageFormat> for ImageOutputFormat

pub fn from(fmt: ImageFormat) -> ImageOutputFormat

impl From<PathError> for ImageError

pub fn from(path: PathError) -> ImageError

impl From<DecoderError> for ImageError

pub fn from(e: DecoderError) -> ImageError

impl From<NeuQuant> for NeuQuant

pub fn from(this: NeuQuant) -> NeuQuant

impl<T> From<[T; 3]> for Bgr<T> where
    T: 'static + Primitive, 

pub fn from(c: [T; 3]) -> Bgr<T>

impl From<ImageFormat> for ImageFormatHint

pub fn from(format: ImageFormat) -> ImageFormatHint

impl<T> From<[T; 1]> for Luma<T> where
    T: 'static + Primitive, 

pub fn from(c: [T; 1]) -> Luma<T>

impl<T> From<[T; 3]> for Rgb<T> where
    T: 'static + Primitive, 

pub fn from(c: [T; 3]) -> Rgb<T>

impl<T> From<T> for Ratio<T> where
    T: Clone + Integer, 

pub fn from(x: T) -> Ratio<T>

impl<T> From<(T, T)> for Ratio<T> where
    T: Clone + Integer, 

pub fn from(pair: (T, T)) -> Ratio<T>

impl From<String> for DecodingError

pub fn from(err: String) -> DecodingError

impl From<Error> for DecodingError

pub fn from(err: Error) -> DecodingError

impl From<Error> for EncodingError

pub fn from(err: Error) -> EncodingError

impl From<EncodingError> for Error

pub fn from(err: EncodingError) -> Error

impl From<Compression> for Compression

pub fn from(c: Compression) -> Compression

impl From<Compression> for CompressionOptions

pub fn from(c: Compression) -> CompressionOptions

impl From<DecodingError> for Error

pub fn from(err: DecodingError) -> Error

impl From<Compression> for CompressionOptions

pub fn from(compression: Compression) -> CompressionOptions

impl From<MZFlush> for TDEFLFlush

pub fn from(flush: MZFlush) -> TDEFLFlush

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl From<Error> for Error

pub fn from(err: Error) -> Error

impl From<Vec<(Path, Error)>> for Error

pub fn from(errs: Vec<(Path, Error)>) -> Error

impl From<u64> for Number

pub fn from(u: u64) -> Number

impl From<isize> for Number

pub fn from(i: isize) -> Number

impl From<i64> for Number

pub fn from(i: i64) -> Number

impl From<u16> for Number

pub fn from(u: u16) -> Number

impl From<i8> for Value

pub fn from(n: i8) -> Value

impl From<u32> for Number

pub fn from(u: u32) -> Number

impl From<i16> for Value

pub fn from(n: i16) -> Value

impl From<i64> for Value

pub fn from(n: i64) -> Value

impl From<()> for Value

pub fn from(()) -> Value

Convert () to Value

Examples

use serde_json::Value;

let u = ();
let x: Value = u.into();

impl From<Error> for Error

pub fn from(j: Error) -> Error

Convert a serde_json::Error into an io::Error.

JSON syntax and data errors are turned into InvalidData IO errors. EOF errors are turned into UnexpectedEof IO errors.

use std::io;

enum MyError {
    Io(io::Error),
    Json(serde_json::Error),
}

impl From<serde_json::Error> for MyError {
    fn from(err: serde_json::Error) -> MyError {
        use serde_json::error::Category;
        match err.classify() {
            Category::Io => {
                MyError::Io(err.into())
            }
            Category::Syntax | Category::Data | Category::Eof => {
                MyError::Json(err)
            }
        }
    }
}

impl From<Map<String, Value>> for Value

pub fn from(f: Map<String, Value>) -> Value

Convert map (with string keys) to Value

Examples

use serde_json::{Map, Value};

let mut m = Map::new();
m.insert("Lorem".to_string(), "ipsum".into());
let x: Value = m.into();

impl From<i16> for Number

pub fn from(i: i16) -> Number

impl From<isize> for Value

pub fn from(n: isize) -> Value

impl From<usize> for Number

pub fn from(u: usize) -> Number

impl From<String> for Value

pub fn from(f: String) -> Value

Convert String to Value

Examples

use serde_json::Value;

let s: String = "lorem".to_string();
let x: Value = s.into();

impl From<u16> for Value

pub fn from(n: u16) -> Value

impl From<bool> for Value

pub fn from(f: bool) -> Value

Convert boolean to Value

Examples

use serde_json::Value;

let b = false;
let x: Value = b.into();

impl From<i32> for Number

pub fn from(i: i32) -> Number

impl From<u8> for Value

pub fn from(n: u8) -> Value

impl<'a> From<Cow<'a, str>> for Value

pub fn from(f: Cow<'a, str>) -> Value

Convert copy-on-write string to Value

Examples

use serde_json::Value;
use std::borrow::Cow;

let s: Cow<str> = Cow::Borrowed("lorem");
let x: Value = s.into();

use serde_json::Value;
use std::borrow::Cow;

let s: Cow<str> = Cow::Owned("lorem".to_string());
let x: Value = s.into();

impl From<u64> for Value

pub fn from(n: u64) -> Value

impl<T> From<Vec<T>> for Value where
    T: Into<Value>, 

pub fn from(f: Vec<T>) -> Value

Convert a Vec to Value

Examples

use serde_json::Value;

let v = vec!["lorem", "ipsum", "dolor"];
let x: Value = v.into();

impl<'a> From<&'a str> for Value

pub fn from(f: &str) -> Value

Convert string slice to Value

Examples

use serde_json::Value;

let s: &str = "lorem";
let x: Value = s.into();

impl From<i8> for Number

pub fn from(i: i8) -> Number

impl From<f32> for Value

pub fn from(f: f32) -> Value

Convert 32-bit floating point number to Value

Examples

use serde_json::Value;

let f: f32 = 13.37;
let x: Value = f.into();

impl From<f64> for Value

pub fn from(f: f64) -> Value

Convert 64-bit floating point number to Value

Examples

use serde_json::Value;

let f: f64 = 13.37;
let x: Value = f.into();

impl From<u32> for Value

pub fn from(n: u32) -> Value

impl<'a, T> From<&'a [T]> for Value where
    T: Clone + Into<Value>, 

pub fn from(f: &'a [T]) -> Value

Convert a slice to Value

Examples

use serde_json::Value;

let v: &[&str] = &["lorem", "ipsum", "dolor"];
let x: Value = v.into();

impl From<ParserNumber> for Number

pub fn from(value: ParserNumber) -> Number

impl From<i32> for Value

pub fn from(n: i32) -> Value

impl From<usize> for Value

pub fn from(n: usize) -> Value

impl From<u8> for Number

pub fn from(u: u8) -> Number

impl<T, U> From<[T; 2]> for Vector2D<T, U>

pub fn from([T; 2]) -> Vector2D<T, U>

impl<T, U> From<(T, T)> for Size2D<T, U>

pub fn from(tuple: (T, T)) -> Size2D<T, U>

impl<T, U> From<Size2D<T, U>> for Rect<T, U> where
    T: Zero, 

pub fn from(size: Size2D<T, U>) -> Rect<T, U>

impl<T, Src, Dst> From<Rotation3D<T, Src, Dst>> for RigidTransform3D<T, Src, Dst> where
    T: ApproxEq<T> + Float, 

pub fn from(rot: Rotation3D<T, Src, Dst>) -> RigidTransform3D<T, Src, Dst>

impl<T, U> From<Point3D<T, U>> for HomogeneousVector<T, U> where
    T: One, 

pub fn from(p: Point3D<T, U>) -> HomogeneousVector<T, U>

impl<T, U> From<Size2D<T, U>> for Vector2D<T, U>

pub fn from(size: Size2D<T, U>) -> Vector2D<T, U>

impl<T, U> From<[T; 3]> for Point3D<T, U>

pub fn from([T; 3]) -> Point3D<T, U>

impl<T, U> From<Size2D<T, U>> for Box2D<T, U> where
    T: Copy + Zero + PartialOrd<T>, 

pub fn from(b: Size2D<T, U>) -> Box2D<T, U>

impl<T, U> From<[T; 3]> for Size3D<T, U>

pub fn from([T; 3]) -> Size3D<T, U>

impl<T, U> From<Vector3D<T, U>> for HomogeneousVector<T, U> where
    T: Zero, 

pub fn from(v: Vector3D<T, U>) -> HomogeneousVector<T, U>

impl<T, U> From<[T; 2]> for Size2D<T, U>

pub fn from([T; 2]) -> Size2D<T, U>

impl<T, U> From<[T; 3]> for Vector3D<T, U>

pub fn from([T; 3]) -> Vector3D<T, U>

impl<T, U> From<(T, T)> for Vector2D<T, U>

pub fn from(tuple: (T, T)) -> Vector2D<T, U>

impl<T, U> From<Vector2D<T, U>> for Size2D<T, U>

pub fn from(v: Vector2D<T, U>) -> Size2D<T, U>

impl<T, Src, Dst> From<Vector3D<T, Dst>> for RigidTransform3D<T, Src, Dst> where
    T: ApproxEq<T> + Float, 

pub fn from(t: Vector3D<T, Dst>) -> RigidTransform3D<T, Src, Dst>

impl<T, U> From<(T, T, T)> for Size3D<T, U>

pub fn from(tuple: (T, T, T)) -> Size3D<T, U>

impl<T, U> From<Point2D<T, U>> for HomogeneousVector<T, U> where
    T: Zero + One, 

pub fn from(p: Point2D<T, U>) -> HomogeneousVector<T, U>

impl<T, U> From<[T; 2]> for Point2D<T, U>

pub fn from([T; 2]) -> Point2D<T, U>

impl<T, U> From<(T, T, T)> for Point3D<T, U>

pub fn from(tuple: (T, T, T)) -> Point3D<T, U>

impl<T, U> From<(T, T, T)> for Vector3D<T, U>

pub fn from(tuple: (T, T, T)) -> Vector3D<T, U>

impl<T, Src, Dst> From<Vector2D<T, Src>> for Translation2D<T, Src, Dst>

pub fn from(v: Vector2D<T, Src>) -> Translation2D<T, Src, Dst>

impl<T, U> From<Size3D<T, U>> for Box3D<T, U> where
    T: Copy + Zero + PartialOrd<T>, 

pub fn from(b: Size3D<T, U>) -> Box3D<T, U>

impl<T, Src, Dst> From<Vector3D<T, Src>> for Translation3D<T, Src, Dst>

pub fn from(v: Vector3D<T, Src>) -> Translation3D<T, Src, Dst>

impl<T, U> From<Vector2D<T, U>> for HomogeneousVector<T, U> where
    T: Zero, 

pub fn from(v: Vector2D<T, U>) -> HomogeneousVector<T, U>

impl<T, U> From<Vector3D<T, U>> for Size3D<T, U>

pub fn from(v: Vector3D<T, U>) -> Size3D<T, U>

impl<T, U> From<(T, T)> for Point2D<T, U>

pub fn from(tuple: (T, T)) -> Point2D<T, U>

impl From<Arc<dyn Font + 'static + Sync + Send>> for FontArc

pub fn from(font: Arc<dyn Font + 'static + Sync + Send>) -> FontArc

impl From<FontRef<'static>> for FontArc

pub fn from(font: FontRef<'static>) -> FontArc

impl From<GlyphId> for GlyphId

pub fn from(id: GlyphId) -> GlyphId

impl From<f32> for PxScale

pub fn from(s: f32) -> PxScale

Uniform scaling where x & y are the same.

impl From<FontVec> for FontArc

pub fn from(font: FontVec) -> FontArc

impl<F> From<[F; 2]> for Point where
    F: Into<f32>, 

pub fn from([F; 2]) -> Point

let p: Point = [23_f32, 34.5].into();
let p2: Point = [5u8, 44].into();

impl<F> From<(F, F)> for Point where
    F: Into<f32>, 

pub fn from((F, F)) -> Point

let p: Point = (23_f32, 34.5_f32).into();
let p2: Point = (5u8, 44u8).into();

impl From<u16> for Weight

pub fn from(value: u16) -> Weight

impl From<f32> for NormalizedCoordinate

pub fn from(n: f32) -> NormalizedCoordinate

Creates a new coordinate.

The provided number will be clamped to the -1.0..1.0 range.

impl From<i16> for NormalizedCoordinate

pub fn from(n: i16) -> NormalizedCoordinate

Creates a new coordinate.

The provided number will be clamped to the -16384..16384 range.

impl From<FlexDirection> for FlexDirection

pub fn from(value: FlexDirection) -> FlexDirection

impl From<AlignSelf> for AlignSelf

pub fn from(value: AlignSelf) -> AlignSelf

impl<'_> From<&'_ Style> for Style

pub fn from(value: &Style) -> Style

impl From<Val> for Dimension

pub fn from(val: Val) -> Dimension

impl From<Display> for Display

pub fn from(value: Display) -> Display

impl From<AlignItems> for AlignItems

pub fn from(value: AlignItems) -> AlignItems

impl From<JustifyContent> for JustifyContent

pub fn from(value: JustifyContent) -> JustifyContent

impl From<Direction> for Direction

pub fn from(value: Direction) -> Direction

impl From<AlignContent> for AlignContent

pub fn from(value: AlignContent) -> AlignContent

impl From<PositionType> for PositionType

pub fn from(value: PositionType) -> PositionType

impl From<FlexWrap> for FlexWrap

pub fn from(value: FlexWrap) -> FlexWrap

impl<P, X> From<(X, X)> for LogicalSize<P> where
    P: Pixel,
    X: Pixel, 

pub fn from((X, X)) -> LogicalSize<P>

impl<P> From<PhysicalPosition<P>> for Position where
    P: Pixel, 

pub fn from(position: PhysicalPosition<P>) -> Position

impl From<OpenError> for XNotSupported

pub fn from(err: OpenError) -> XNotSupported

impl<P> From<LogicalPosition<P>> for Position where
    P: Pixel, 

pub fn from(position: LogicalPosition<P>) -> Position

impl<P> From<PhysicalSize<P>> for Size where
    P: Pixel, 

pub fn from(size: PhysicalSize<P>) -> Size

impl<P, X> From<(X, X)> for LogicalPosition<P> where
    P: Pixel,
    X: Pixel, 

pub fn from((X, X)) -> LogicalPosition<P>

impl<P, X> From<[X; 2]> for PhysicalSize<P> where
    P: Pixel,
    X: Pixel, 

pub fn from([X; 2]) -> PhysicalSize<P>

impl<P, X> From<[X; 2]> for LogicalPosition<P> where
    P: Pixel,
    X: Pixel, 

pub fn from([X; 2]) -> LogicalPosition<P>

impl<P, X> From<[X; 2]> for PhysicalPosition<P> where
    P: Pixel,
    X: Pixel, 

pub fn from([X; 2]) -> PhysicalPosition<P>

impl<P, X> From<(X, X)> for PhysicalSize<P> where
    P: Pixel,
    X: Pixel, 

pub fn from((X, X)) -> PhysicalSize<P>

impl<P, X> From<[X; 2]> for LogicalSize<P> where
    P: Pixel,
    X: Pixel, 

pub fn from([X; 2]) -> LogicalSize<P>

impl From<bool> for StateOperation

pub fn from(op: bool) -> StateOperation

impl<P> From<LogicalSize<P>> for Size where
    P: Pixel, 

pub fn from(size: LogicalSize<P>) -> Size

impl<P, X> From<(X, X)> for PhysicalPosition<P> where
    P: Pixel,
    X: Pixel, 

pub fn from((X, X)) -> PhysicalPosition<P>

impl<'a> From<PercentEncode<'a>> for Cow<'a, str>

pub fn from(iter: PercentEncode<'a>) -> Cow<'a, str>

impl<'a> From<PercentDecode<'a>> for Cow<'a, [u8]>

pub fn from(iter: PercentDecode<'a>) -> Cow<'a, [u8]>

impl<'a> From<&'a XMappingEvent> for XEvent

pub fn from(other: &'a XMappingEvent) -> XEvent

impl<'a> From<&'a XF86VidModeNotifyEvent> for XEvent

pub fn from(other: &'a XF86VidModeNotifyEvent) -> XEvent

impl<'a> From<&'a XEvent> for XDestroyWindowEvent

pub fn from(xevent: &'a XEvent) -> XDestroyWindowEvent

impl From<XEvent> for XMappingEvent

pub fn from(xevent: XEvent) -> XMappingEvent

impl<'a> From<&'a XEvent> for XGravityEvent

pub fn from(xevent: &'a XEvent) -> XGravityEvent

impl<'a> From<&'a XButtonEvent> for XEvent

pub fn from(other: &'a XButtonEvent) -> XEvent

impl From<[i8; 20]> for ClientMessageData

pub fn from(array: [i8; 20]) -> ClientMessageData

impl<'a> From<&'a XEvent> for XMapEvent

pub fn from(xevent: &'a XEvent) -> XMapEvent

impl From<XEvent> for XConfigureEvent

pub fn from(xevent: XEvent) -> XConfigureEvent

impl From<XF86VidModeNotifyEvent> for XEvent

pub fn from(other: XF86VidModeNotifyEvent) -> XEvent

impl<'a> From<&'a XEvent> for XConfigureEvent

pub fn from(xevent: &'a XEvent) -> XConfigureEvent

impl<'a> From<&'a XScreenSaverNotifyEvent> for XEvent

pub fn from(other: &'a XScreenSaverNotifyEvent) -> XEvent

impl From<XMapEvent> for XEvent

pub fn from(other: XMapEvent) -> XEvent

impl From<XEvent> for XColormapEvent

pub fn from(xevent: XEvent) -> XColormapEvent

impl<'a> From<&'a XEvent> for XRROutputChangeNotifyEvent

pub fn from(xevent: &'a XEvent) -> XRROutputChangeNotifyEvent

impl From<XKeyEvent> for XEvent

pub fn from(other: XKeyEvent) -> XEvent

impl<'a> From<&'a XUnmapEvent> for XEvent

pub fn from(other: &'a XUnmapEvent) -> XEvent

impl<'a> From<&'a XEvent> for XMapRequestEvent

pub fn from(xevent: &'a XEvent) -> XMapRequestEvent

impl<'a> From<&'a XCirculateEvent> for XEvent

pub fn from(other: &'a XCirculateEvent) -> XEvent

impl From<XEvent> for XClientMessageEvent

pub fn from(xevent: XEvent) -> XClientMessageEvent

impl From<XSelectionClearEvent> for XEvent

pub fn from(other: XSelectionClearEvent) -> XEvent

impl From<XRRResourceChangeNotifyEvent> for XEvent

pub fn from(other: XRRResourceChangeNotifyEvent) -> XEvent

impl From<XKeymapEvent> for XEvent

pub fn from(other: XKeymapEvent) -> XEvent

impl From<XResizeRequestEvent> for XEvent

pub fn from(other: XResizeRequestEvent) -> XEvent

impl From<XEvent> for XRRResourceChangeNotifyEvent

pub fn from(xevent: XEvent) -> XRRResourceChangeNotifyEvent

impl<'a> From<&'a XSelectionEvent> for XEvent

pub fn from(other: &'a XSelectionEvent) -> XEvent

impl<'a> From<&'a XRRProviderPropertyNotifyEvent> for XEvent

pub fn from(other: &'a XRRProviderPropertyNotifyEvent) -> XEvent

impl From<XEvent> for XF86VidModeNotifyEvent

pub fn from(xevent: XEvent) -> XF86VidModeNotifyEvent

impl From<XEvent> for XButtonEvent

pub fn from(xevent: XEvent) -> XButtonEvent

impl From<XEvent> for XRRProviderChangeNotifyEvent

pub fn from(xevent: XEvent) -> XRRProviderChangeNotifyEvent

impl From<XConfigureRequestEvent> for XEvent

pub fn from(other: XConfigureRequestEvent) -> XEvent

impl<'a> From<&'a XAnyEvent> for XEvent

pub fn from(other: &'a XAnyEvent) -> XEvent

impl<'a> From<&'a XColormapEvent> for XEvent

pub fn from(other: &'a XColormapEvent) -> XEvent

impl From<XEvent> for XReparentEvent

pub fn from(xevent: XEvent) -> XReparentEvent

impl From<[i64; 5]> for ClientMessageData

pub fn from(array: [i64; 5]) -> ClientMessageData

impl From<XEvent> for XKeyEvent

pub fn from(xevent: XEvent) -> XKeyEvent

impl From<XCreateWindowEvent> for XEvent

pub fn from(other: XCreateWindowEvent) -> XEvent

impl From<XUnmapEvent> for XEvent

pub fn from(other: XUnmapEvent) -> XEvent

impl From<XGraphicsExposeEvent> for XEvent

pub fn from(other: XGraphicsExposeEvent) -> XEvent

impl From<XEvent> for XGraphicsExposeEvent

pub fn from(xevent: XEvent) -> XGraphicsExposeEvent

impl From<XEvent> for XSelectionClearEvent

pub fn from(xevent: XEvent) -> XSelectionClearEvent

impl<'a> From<&'a XEvent> for XCirculateEvent

pub fn from(xevent: &'a XEvent) -> XCirculateEvent

impl From<XPropertyEvent> for XEvent

pub fn from(other: XPropertyEvent) -> XEvent

impl From<XEvent> for XCirculateEvent

pub fn from(xevent: XEvent) -> XCirculateEvent

impl<'a> From<&'a XEvent> for XVisibilityEvent

pub fn from(xevent: &'a XEvent) -> XVisibilityEvent

impl From<XRRCrtcChangeNotifyEvent> for XEvent

pub fn from(other: XRRCrtcChangeNotifyEvent) -> XEvent

impl From<XEvent> for XVisibilityEvent

pub fn from(xevent: XEvent) -> XVisibilityEvent

impl<'a> From<&'a XEvent> for XRRResourceChangeNotifyEvent

pub fn from(xevent: &'a XEvent) -> XRRResourceChangeNotifyEvent

impl From<XEvent> for XErrorEvent

pub fn from(xevent: XEvent) -> XErrorEvent

impl<'a> From<&'a XEvent> for XFocusChangeEvent

pub fn from(xevent: &'a XEvent) -> XFocusChangeEvent

impl From<[u64; 5]> for ClientMessageData

pub fn from(array: [u64; 5]) -> ClientMessageData

impl<'a> From<&'a XDestroyWindowEvent> for XEvent

pub fn from(other: &'a XDestroyWindowEvent) -> XEvent

impl<'a> From<&'a XCirculateRequestEvent> for XEvent

pub fn from(other: &'a XCirculateRequestEvent) -> XEvent

impl<'a> From<&'a XEvent> for XNoExposeEvent

pub fn from(xevent: &'a XEvent) -> XNoExposeEvent

impl From<XEvent> for XAnyEvent

pub fn from(xevent: XEvent) -> XAnyEvent

impl<'a> From<&'a XEvent> for XCreateWindowEvent

pub fn from(xevent: &'a XEvent) -> XCreateWindowEvent

impl From<XRRScreenChangeNotifyEvent> for XEvent

pub fn from(other: XRRScreenChangeNotifyEvent) -> XEvent

impl From<XEvent> for XRRScreenChangeNotifyEvent

pub fn from(xevent: XEvent) -> XRRScreenChangeNotifyEvent

impl<'a> From<&'a XEvent> for XMotionEvent

pub fn from(xevent: &'a XEvent) -> XMotionEvent

impl<'a> From<&'a XRRResourceChangeNotifyEvent> for XEvent

pub fn from(other: &'a XRRResourceChangeNotifyEvent) -> XEvent

impl<'a> From<&'a XGraphicsExposeEvent> for XEvent

pub fn from(other: &'a XGraphicsExposeEvent) -> XEvent

impl<'a> From<&'a XEvent> for XResizeRequestEvent

pub fn from(xevent: &'a XEvent) -> XResizeRequestEvent

impl<'a> From<&'a XEvent> for XGraphicsExposeEvent

pub fn from(xevent: &'a XEvent) -> XGraphicsExposeEvent

impl From<XButtonEvent> for XEvent

pub fn from(other: XButtonEvent) -> XEvent

impl<'a> From<&'a XClientMessageEvent> for XEvent

pub fn from(other: &'a XClientMessageEvent) -> XEvent

impl<'a> From<&'a XEvent> for XRRNotifyEvent

pub fn from(xevent: &'a XEvent) -> XRRNotifyEvent

impl<'a> From<&'a XVisibilityEvent> for XEvent

pub fn from(other: &'a XVisibilityEvent) -> XEvent

impl From<XEvent> for XRROutputPropertyNotifyEvent

pub fn from(xevent: XEvent) -> XRROutputPropertyNotifyEvent

impl<'a> From<&'a XEvent> for XSelectionRequestEvent

pub fn from(xevent: &'a XEvent) -> XSelectionRequestEvent

impl From<XErrorEvent> for XEvent

pub fn from(other: XErrorEvent) -> XEvent

impl From<XEvent> for XExposeEvent

pub fn from(xevent: XEvent) -> XExposeEvent

impl From<XExposeEvent> for XEvent

pub fn from(other: XExposeEvent) -> XEvent

impl From<XMapRequestEvent> for XEvent

pub fn from(other: XMapRequestEvent) -> XEvent

impl<'a> From<&'a XRRProviderChangeNotifyEvent> for XEvent

pub fn from(other: &'a XRRProviderChangeNotifyEvent) -> XEvent

impl<'a> From<&'a XCrossingEvent> for XEvent

pub fn from(other: &'a XCrossingEvent) -> XEvent

impl From<XSelectionEvent> for XEvent

pub fn from(other: XSelectionEvent) -> XEvent

impl From<XReparentEvent> for XEvent

pub fn from(other: XReparentEvent) -> XEvent

impl From<[u8; 20]> for ClientMessageData

pub fn from(array: [u8; 20]) -> ClientMessageData

impl<'a> From<&'a XSelectionRequestEvent> for XEvent

pub fn from(other: &'a XSelectionRequestEvent) -> XEvent

impl From<XEvent> for XResizeRequestEvent

pub fn from(xevent: XEvent) -> XResizeRequestEvent

impl From<[u16; 10]> for ClientMessageData

pub fn from(array: [u16; 10]) -> ClientMessageData

impl From<XEvent> for XCrossingEvent

pub fn from(xevent: XEvent) -> XCrossingEvent

impl<'a> From<&'a XEvent> for XErrorEvent

pub fn from(xevent: &'a XEvent) -> XErrorEvent

impl From<XEvent> for XMapEvent

pub fn from(xevent: XEvent) -> XMapEvent

impl<'a> From<&'a XRROutputChangeNotifyEvent> for XEvent

pub fn from(other: &'a XRROutputChangeNotifyEvent) -> XEvent

impl<'a> From<&'a XEvent> for XMappingEvent

pub fn from(xevent: &'a XEvent) -> XMappingEvent

impl<'a> From<&'a XMapRequestEvent> for XEvent

pub fn from(other: &'a XMapRequestEvent) -> XEvent

impl<'a> From<&'a XEvent> for XRRProviderPropertyNotifyEvent

pub fn from(xevent: &'a XEvent) -> XRRProviderPropertyNotifyEvent

impl<'a> From<&'a XRRCrtcChangeNotifyEvent> for XEvent

pub fn from(other: &'a XRRCrtcChangeNotifyEvent) -> XEvent

impl<'a> From<&'a XEvent> for XButtonEvent

pub fn from(xevent: &'a XEvent) -> XButtonEvent

impl From<XAnyEvent> for XEvent

pub fn from(other: XAnyEvent) -> XEvent

impl<'a> From<&'a XEvent> for XKeymapEvent

pub fn from(xevent: &'a XEvent) -> XKeymapEvent

impl From<XEvent> for XRROutputChangeNotifyEvent

pub fn from(xevent: XEvent) -> XRROutputChangeNotifyEvent

impl<'a> From<&'a XEvent> for XRRScreenChangeNotifyEvent

pub fn from(xevent: &'a XEvent) -> XRRScreenChangeNotifyEvent

impl From<XEvent> for XScreenSaverNotifyEvent

pub fn from(xevent: XEvent) -> XScreenSaverNotifyEvent

impl From<XRROutputPropertyNotifyEvent> for XEvent

pub fn from(other: XRROutputPropertyNotifyEvent) -> XEvent

impl<'a> From<&'a XRRNotifyEvent> for XEvent

pub fn from(other: &'a XRRNotifyEvent) -> XEvent

impl From<XEvent> for XPropertyEvent

pub fn from(xevent: XEvent) -> XPropertyEvent

impl<'a> From<&'a XEvent> for XRRCrtcChangeNotifyEvent

pub fn from(xevent: &'a XEvent) -> XRRCrtcChangeNotifyEvent

impl<'a> From<&'a XEvent> for XCirculateRequestEvent

pub fn from(xevent: &'a XEvent) -> XCirculateRequestEvent

impl<'a> From<&'a XKeyEvent> for XEvent

pub fn from(other: &'a XKeyEvent) -> XEvent

impl From<XEvent> for XKeymapEvent

pub fn from(xevent: XEvent) -> XKeymapEvent

impl<'a> From<&'a XEvent> for XReparentEvent

pub fn from(xevent: &'a XEvent) -> XReparentEvent

impl From<XCrossingEvent> for XEvent

pub fn from(other: XCrossingEvent) -> XEvent

impl From<XEvent> for XUnmapEvent

pub fn from(xevent: XEvent) -> XUnmapEvent

impl From<XEvent> for XSelectionEvent

pub fn from(xevent: XEvent) -> XSelectionEvent

impl From<XEvent> for XRRCrtcChangeNotifyEvent

pub fn from(xevent: XEvent) -> XRRCrtcChangeNotifyEvent

impl<'a> From<&'a XPropertyEvent> for XEvent

pub fn from(other: &'a XPropertyEvent) -> XEvent

impl From<XColormapEvent> for XEvent

pub fn from(other: XColormapEvent) -> XEvent

impl<'a> From<&'a XEvent> for XF86VidModeNotifyEvent

pub fn from(xevent: &'a XEvent) -> XF86VidModeNotifyEvent

impl From<XEvent> for XRRNotifyEvent

pub fn from(xevent: XEvent) -> XRRNotifyEvent

impl<'a> From<&'a XKeymapEvent> for XEvent

pub fn from(other: &'a XKeymapEvent) -> XEvent

impl<'a> From<&'a XConfigureRequestEvent> for XEvent

pub fn from(other: &'a XConfigureRequestEvent) -> XEvent

impl From<XNoExposeEvent> for XEvent

pub fn from(other: XNoExposeEvent) -> XEvent

impl From<XEvent> for XMapRequestEvent

pub fn from(xevent: XEvent) -> XMapRequestEvent

impl From<XVisibilityEvent> for XEvent

pub fn from(other: XVisibilityEvent) -> XEvent

impl From<XEvent> for XMotionEvent

pub fn from(xevent: XEvent) -> XMotionEvent

impl From<XMappingEvent> for XEvent

pub fn from(other: XMappingEvent) -> XEvent

impl<'a> From<&'a XEvent> for XKeyEvent

pub fn from(xevent: &'a XEvent) -> XKeyEvent

impl From<XGravityEvent> for XEvent

pub fn from(other: XGravityEvent) -> XEvent

impl<'a> From<&'a XEvent> for XClientMessageEvent

pub fn from(xevent: &'a XEvent) -> XClientMessageEvent

impl From<XRROutputChangeNotifyEvent> for XEvent

pub fn from(other: XRROutputChangeNotifyEvent) -> XEvent

impl<'a> From<&'a XErrorEvent> for XEvent

pub fn from(other: &'a XErrorEvent) -> XEvent

impl<'a> From<&'a XEvent> for XPropertyEvent

pub fn from(xevent: &'a XEvent) -> XPropertyEvent

impl<'a> From<&'a XGravityEvent> for XEvent

pub fn from(other: &'a XGravityEvent) -> XEvent

impl<'a> From<&'a XEvent> for XRROutputPropertyNotifyEvent

pub fn from(xevent: &'a XEvent) -> XRROutputPropertyNotifyEvent

impl From<XEvent> for XCreateWindowEvent

pub fn from(xevent: XEvent) -> XCreateWindowEvent

impl From<XClientMessageEvent> for XEvent

pub fn from(other: XClientMessageEvent) -> XEvent

impl From<XEvent> for XNoExposeEvent

pub fn from(xevent: XEvent) -> XNoExposeEvent

impl<'a> From<&'a XResizeRequestEvent> for XEvent

pub fn from(other: &'a XResizeRequestEvent) -> XEvent

impl<'a> From<&'a XSelectionClearEvent> for XEvent

pub fn from(other: &'a XSelectionClearEvent) -> XEvent

impl From<XRRNotifyEvent> for XEvent

pub fn from(other: XRRNotifyEvent) -> XEvent

impl From<XEvent> for XFocusChangeEvent

pub fn from(xevent: XEvent) -> XFocusChangeEvent

impl<'a> From<&'a XNoExposeEvent> for XEvent

pub fn from(other: &'a XNoExposeEvent) -> XEvent

impl<'a> From<&'a XCreateWindowEvent> for XEvent

pub fn from(other: &'a XCreateWindowEvent) -> XEvent

impl From<XConfigureEvent> for XEvent

pub fn from(other: XConfigureEvent) -> XEvent

impl From<XEvent> for XSelectionRequestEvent

pub fn from(xevent: XEvent) -> XSelectionRequestEvent

impl From<XGenericEventCookie> for XEvent

pub fn from(other: XGenericEventCookie) -> XEvent

impl From<XEvent> for XConfigureRequestEvent

pub fn from(xevent: XEvent) -> XConfigureRequestEvent

impl<'a> From<&'a XEvent> for XSelectionClearEvent

pub fn from(xevent: &'a XEvent) -> XSelectionClearEvent

impl<'a> From<&'a XReparentEvent> for XEvent

pub fn from(other: &'a XReparentEvent) -> XEvent

impl<'a> From<&'a XConfigureEvent> for XEvent

pub fn from(other: &'a XConfigureEvent) -> XEvent

impl From<XScreenSaverNotifyEvent> for XEvent

pub fn from(other: XScreenSaverNotifyEvent) -> XEvent

impl<'a> From<&'a XEvent> for XColormapEvent

pub fn from(xevent: &'a XEvent) -> XColormapEvent

impl From<XEvent> for XRRProviderPropertyNotifyEvent

pub fn from(xevent: XEvent) -> XRRProviderPropertyNotifyEvent

impl<'a> From<&'a XEvent> for XScreenSaverNotifyEvent

pub fn from(xevent: &'a XEvent) -> XScreenSaverNotifyEvent

impl<'a> From<&'a XRRScreenChangeNotifyEvent> for XEvent

pub fn from(other: &'a XRRScreenChangeNotifyEvent) -> XEvent

impl<'a> From<&'a XExposeEvent> for XEvent

pub fn from(other: &'a XExposeEvent) -> XEvent

impl From<XEvent> for XGenericEventCookie

pub fn from(xevent: XEvent) -> XGenericEventCookie

impl<'a> From<&'a XEvent> for XRRProviderChangeNotifyEvent

pub fn from(xevent: &'a XEvent) -> XRRProviderChangeNotifyEvent

impl<'a> From<&'a XEvent> for XConfigureRequestEvent

pub fn from(xevent: &'a XEvent) -> XConfigureRequestEvent

impl<'a> From<&'a XEvent> for XCrossingEvent

pub fn from(xevent: &'a XEvent) -> XCrossingEvent

impl<'a> From<&'a XGenericEventCookie> for XEvent

pub fn from(other: &'a XGenericEventCookie) -> XEvent

impl<'a> From<&'a XEvent> for XAnyEvent

pub fn from(xevent: &'a XEvent) -> XAnyEvent

impl From<XCirculateRequestEvent> for XEvent

pub fn from(other: XCirculateRequestEvent) -> XEvent

impl From<XEvent> for XDestroyWindowEvent

pub fn from(xevent: XEvent) -> XDestroyWindowEvent

impl<'a> From<&'a XMapEvent> for XEvent

pub fn from(other: &'a XMapEvent) -> XEvent

impl From<XFocusChangeEvent> for XEvent

pub fn from(other: XFocusChangeEvent) -> XEvent

impl From<XDestroyWindowEvent> for XEvent

pub fn from(other: XDestroyWindowEvent) -> XEvent

impl<'a> From<&'a XFocusChangeEvent> for XEvent

pub fn from(other: &'a XFocusChangeEvent) -> XEvent

impl<'a> From<&'a XEvent> for XSelectionEvent

pub fn from(xevent: &'a XEvent) -> XSelectionEvent

impl<'a> From<&'a XMotionEvent> for XEvent

pub fn from(other: &'a XMotionEvent) -> XEvent

impl From<[i16; 10]> for ClientMessageData

pub fn from(array: [i16; 10]) -> ClientMessageData

impl<'a> From<&'a XEvent> for XExposeEvent

pub fn from(xevent: &'a XEvent) -> XExposeEvent

impl From<XEvent> for XGravityEvent

pub fn from(xevent: XEvent) -> XGravityEvent

impl<'a> From<&'a XEvent> for XUnmapEvent

pub fn from(xevent: &'a XEvent) -> XUnmapEvent

impl<'a> From<&'a XRROutputPropertyNotifyEvent> for XEvent

pub fn from(other: &'a XRROutputPropertyNotifyEvent) -> XEvent

impl From<XRRProviderPropertyNotifyEvent> for XEvent

pub fn from(other: XRRProviderPropertyNotifyEvent) -> XEvent

impl<'a> From<&'a XEvent> for XGenericEventCookie

pub fn from(xevent: &'a XEvent) -> XGenericEventCookie

impl From<XEvent> for XCirculateRequestEvent

pub fn from(xevent: XEvent) -> XCirculateRequestEvent

impl From<XMotionEvent> for XEvent

pub fn from(other: XMotionEvent) -> XEvent

impl From<XCirculateEvent> for XEvent

pub fn from(other: XCirculateEvent) -> XEvent

impl From<XRRProviderChangeNotifyEvent> for XEvent

pub fn from(other: XRRProviderChangeNotifyEvent) -> XEvent

impl From<XSelectionRequestEvent> for XEvent

pub fn from(other: XSelectionRequestEvent) -> XEvent

impl<'a> From<&'a OwnedWgpuVertexBufferDescriptor> for VertexBufferDescriptor<'a>

pub fn from(
    val: &'a OwnedWgpuVertexBufferDescriptor
) -> VertexBufferDescriptor<'a>

impl<A> From<A> for ArrayVec<A> where
    A: Array, 

Create an ArrayVec from an array.

use arrayvec::ArrayVec;

let mut array = ArrayVec::from([1, 2, 3]);
assert_eq!(array.len(), 3);
assert_eq!(array.capacity(), 3);

pub fn from(array: A) -> ArrayVec<A>

impl<T> From<Option<T>> for OptionFuture<T>

pub fn from(option: Option<T>) -> OptionFuture<T>

impl<T> From<T> for Mutex<T>

pub fn from(t: T) -> Mutex<T>

impl<'a, F> From<Box<F>> for FutureObj<'a, ()> where
    F: 'a + Send + Future<Output = ()>, 

pub fn from(boxed: Box<F>) -> FutureObj<'a, ()>

impl<'a> From<Pin<Box<dyn Future<Output = ()> + 'a>>> for LocalFutureObj<'a, ()>

pub fn from(
    boxed: Pin<Box<dyn Future<Output = ()> + 'a>>
) -> LocalFutureObj<'a, ()>

impl<'a, F> From<Pin<Box<F>>> for FutureObj<'a, ()> where
    F: 'a + Send + Future<Output = ()>, 

pub fn from(boxed: Pin<Box<F>>) -> FutureObj<'a, ()>

impl<'a, F> From<Box<F>> for LocalFutureObj<'a, ()> where
    F: 'a + Future<Output = ()>, 

pub fn from(boxed: Box<F>) -> LocalFutureObj<'a, ()>

impl<'a, F> From<Pin<Box<F>>> for LocalFutureObj<'a, ()> where
    F: 'a + Future<Output = ()>, 

pub fn from(boxed: Pin<Box<F>>) -> LocalFutureObj<'a, ()>

impl<'a> From<Pin<Box<dyn Future<Output = ()> + 'a + Send>>> for FutureObj<'a, ()>

pub fn from(
    boxed: Pin<Box<dyn Future<Output = ()> + 'a + Send>>
) -> FutureObj<'a, ()>

impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T>

pub fn from(f: FutureObj<'a, T>) -> LocalFutureObj<'a, T>

impl<'a> From<Box<dyn Future<Output = ()> + 'a>> for LocalFutureObj<'a, ()>

pub fn from(boxed: Box<dyn Future<Output = ()> + 'a>) -> LocalFutureObj<'a, ()>

impl<'a> From<Box<dyn Future<Output = ()> + 'a + Send>> for FutureObj<'a, ()>

pub fn from(
    boxed: Box<dyn Future<Output = ()> + 'a + Send>
) -> FutureObj<'a, ()>

impl From<DeviceError> for CreateComputePipelineError

pub fn from(source: DeviceError) -> CreateComputePipelineError

impl From<DeviceError> for CreateSamplerError

pub fn from(source: DeviceError) -> CreateSamplerError

impl From<CreatePipelineLayoutError> for ImplicitLayoutError

pub fn from(source: CreatePipelineLayoutError) -> ImplicitLayoutError

impl From<DeviceError> for SwapChainError

pub fn from(source: DeviceError) -> SwapChainError

impl From<MissingBufferUsageError> for ComputePassError

pub fn from(source: MissingBufferUsageError) -> ComputePassError

impl From<DeviceError> for CreateRenderPipelineError

pub fn from(source: DeviceError) -> CreateRenderPipelineError

impl From<RenderCommandError> for RenderBundleError

pub fn from(source: RenderCommandError) -> RenderBundleError

impl From<DeviceError> for RenderBundleError

pub fn from(source: DeviceError) -> RenderBundleError

impl From<MissingBufferUsageError> for CreateBindGroupError

pub fn from(source: MissingBufferUsageError) -> CreateBindGroupError

impl From<DeviceType> for DeviceType

pub fn from(device_type: DeviceType) -> DeviceType

impl From<DeviceError> for CreateTextureError

pub fn from(source: DeviceError) -> CreateTextureError

impl From<MissingTextureUsageError> for RenderCommandError

pub fn from(source: MissingTextureUsageError) -> RenderCommandError

impl From<MissingBufferUsageError> for RenderCommandError

pub fn from(source: MissingBufferUsageError) -> RenderCommandError

impl From<CreateBindGroupLayoutError> for ImplicitLayoutError

pub fn from(source: CreateBindGroupLayoutError) -> ImplicitLayoutError

impl From<CommandEncoderError> for CopyError

pub fn from(source: CommandEncoderError) -> CopyError

impl From<DeviceError> for CreatePipelineLayoutError

pub fn from(source: DeviceError) -> CreatePipelineLayoutError

impl From<DeviceError> for CreateSwapChainError

pub fn from(source: DeviceError) -> CreateSwapChainError

impl From<MissingTextureUsageError> for RenderPassError

pub fn from(error: MissingTextureUsageError) -> RenderPassError

impl From<ValidationError> for CreateShaderModuleError

pub fn from(source: ValidationError) -> CreateShaderModuleError

impl From<CommandEncoderError> for RenderPassError

pub fn from(source: CommandEncoderError) -> RenderPassError

impl From<MissingBufferUsageError> for BufferAccessError

pub fn from(source: MissingBufferUsageError) -> BufferAccessError

impl From<PushConstantUploadError> for ComputePassError

pub fn from(source: PushConstantUploadError) -> ComputePassError

impl From<BindError> for ComputePassError

pub fn from(source: BindError) -> ComputePassError

impl From<ImplicitLayoutError> for CreateComputePipelineError

pub fn from(source: ImplicitLayoutError) -> CreateComputePipelineError

impl From<DeviceError> for BufferAccessError

pub fn from(source: DeviceError) -> BufferAccessError

impl From<MissingBufferUsageError> for RenderPassError

pub fn from(error: MissingBufferUsageError) -> RenderPassError

impl From<RenderCommandError> for RenderPassError

pub fn from(source: RenderCommandError) -> RenderPassError

impl From<BindError> for RenderPassError

pub fn from(source: BindError) -> RenderPassError

impl From<TextureDimensionError> for CreateTextureError

pub fn from(source: TextureDimensionError) -> CreateTextureError

impl From<DeviceError> for CreateBindGroupLayoutError

pub fn from(source: DeviceError) -> CreateBindGroupLayoutError

impl From<CommandEncoderError> for ComputePassError

pub fn from(source: CommandEncoderError) -> ComputePassError

impl From<MapError> for BufferAccessError

pub fn from(error: MapError) -> BufferAccessError

impl From<DeviceError> for CommandAllocatorError

pub fn from(source: DeviceError) -> CommandAllocatorError

impl From<DrawError> for RenderPassError

pub fn from(source: DrawError) -> RenderPassError

impl From<OomOrDeviceLost> for DeviceError

pub fn from(err: OomOrDeviceLost) -> DeviceError

impl From<DeviceError> for CreateShaderModuleError

pub fn from(source: DeviceError) -> CreateShaderModuleError

impl From<BufferAccessError> for CreateBufferError

pub fn from(source: BufferAccessError) -> CreateBufferError

impl From<TransferError> for CopyError

pub fn from(source: TransferError) -> CopyError

impl From<MissingTextureUsageError> for CreateBindGroupError

pub fn from(source: MissingTextureUsageError) -> CreateBindGroupError

impl From<DeviceError> for CreateBindGroupError

pub fn from(source: DeviceError) -> CreateBindGroupError

impl From<DrawError> for RenderBundleError

pub fn from(source: DrawError) -> RenderBundleError

impl From<DeviceError> for CreateBufferError

pub fn from(source: DeviceError) -> CreateBufferError

impl From<DispatchError> for ComputePassError

pub fn from(source: DispatchError) -> ComputePassError

impl From<PushConstantUploadError> for RenderCommandError

pub fn from(source: PushConstantUploadError) -> RenderCommandError

impl From<ImplicitLayoutError> for CreateRenderPipelineError

pub fn from(source: ImplicitLayoutError) -> CreateRenderPipelineError

impl From<OutOfMemory> for BindError

pub fn from(error: OutOfMemory) -> BindError

impl From<OutOfMemory> for CreationError

pub fn from(error: OutOfMemory) -> CreationError

impl From<OutOfMemory> for ShaderError

pub fn from(error: OutOfMemory) -> ShaderError

impl From<OutOfMemory> for CreationError

pub fn from(error: OutOfMemory) -> CreationError

impl From<OutOfMemory> for OomOrDeviceLost

pub fn from(error: OutOfMemory) -> OomOrDeviceLost

impl From<SubresourceLayers> for SubresourceRange

pub fn from(sub: SubresourceLayers) -> SubresourceRange

impl From<WindowInUse> for CreationError

pub fn from(error: WindowInUse) -> CreationError

impl From<OutOfMemory> for CreationError

pub fn from(error: OutOfMemory) -> CreationError

impl From<OutOfMemory> for ViewCreationError

pub fn from(error: OutOfMemory) -> ViewCreationError

impl From<[f32; 4]> for PackedColor

pub fn from(c: [f32; 4]) -> PackedColor

impl From<OutOfMemory> for AllocationError

pub fn from(error: OutOfMemory) -> AllocationError

impl From<DeviceLost> for CreationError

pub fn from(error: DeviceLost) -> CreationError

impl<'_, T> From<T> for Specialization<'_> where
    T: SpecConstList, 

pub fn from(list: T) -> Specialization<'_>

impl From<OutOfMemory> for CreationError

pub fn from(error: OutOfMemory) -> CreationError

impl From<Extent> for Extent2D

pub fn from(ex: Extent) -> Extent2D

impl From<OutOfMemory> for MapError

pub fn from(error: OutOfMemory) -> MapError

impl From<SurfaceLost> for CreationError

pub fn from(error: SurfaceLost) -> CreationError

impl From<usize> for MemoryTypeId

pub fn from(id: usize) -> MemoryTypeId

impl From<OutOfMemory> for ViewCreationError

pub fn from(error: OutOfMemory) -> ViewCreationError

impl From<DeviceLost> for OomOrDeviceLost

pub fn from(error: DeviceLost) -> OomOrDeviceLost

impl From<OutOfMemory> for CreationError

pub fn from(err: OutOfMemory) -> CreationError

impl From<Library> for Library

pub fn from(lib: Library) -> Library

impl From<Library> for Library

pub fn from(lib: Library) -> Library

impl From<Backend> for BackendBit

pub fn from(backend: Backend) -> BackendBit

impl From<TextureFormat> for ColorStateDescriptor

pub fn from(format: TextureFormat) -> ColorStateDescriptor

impl From<TextureFormat> for TextureComponentType

pub fn from(format: TextureFormat) -> TextureComponentType

impl From<OutOfMemory> for HeapsError

pub fn from(error: OutOfMemory) -> HeapsError

impl From<AllocationError> for HeapsError

pub fn from(error: AllocationError) -> HeapsError

impl From<Error> for Error

pub fn from(e: Error) -> Error

impl<'a> From<UnexpectedConstantTypeError> for Error<'a>

pub fn from(source: UnexpectedConstantTypeError) -> Error<'a>

impl From<Level> for LevelFilter

pub fn from(level: Level) -> LevelFilter

impl From<Option<Level>> for LevelFilter

pub fn from(level: Option<Level>) -> LevelFilter

impl<S> From<S> for Dispatch where
    S: Subscriber + Send + Sync + 'static, 

pub fn from(subscriber: S) -> Dispatch

impl<T> From<SendError<T>> for Error

pub fn from(SendError<T>) -> Error

impl From<DistanceModelError> for Error

pub fn from(f: DistanceModelError) -> Error

impl From<Duration> for Ticks

pub fn from(dur: Duration) -> Ticks

impl From<input_event> for EvCode

pub fn from(f: input_event) -> EvCode

impl<'a> From<&'a sigevent> for SigEvent

pub fn from(sigevent: &sigevent) -> SigEvent

impl From<termios> for Termios

pub fn from(termios: termios) -> Termios

impl<'_> From<&'_ passwd> for User

pub fn from(pw: &passwd) -> User

impl From<timespec> for TimeSpec

pub fn from(ts: timespec) -> TimeSpec

impl<'a> From<Vec<AioCb<'a>>> for LioCb<'a>

pub fn from(src: Vec<AioCb<'a>>) -> LioCb<'a>

impl From<Errno> for Error

pub fn from(errno: Errno) -> Error

impl From<Termios> for termios

pub fn from(termios: Termios) -> termios

impl From<ucred> for UnixCredentials

pub fn from(cred: ucred) -> UnixCredentials

impl From<timeval> for TimeVal

pub fn from(tv: timeval) -> TimeVal

impl From<Gid> for u32

pub fn from(gid: Gid) -> u32

impl<'_> From<&'_ group> for Group

pub fn from(gr: &group) -> Group

impl From<Errno> for Error

pub fn from(err: Errno) -> Error

impl From<Pid> for i32

pub fn from(pid: Pid) -> i32

impl From<FromUtf8Error> for Error

pub fn from(FromUtf8Error) -> Error

impl From<TimerSpec> for Expiration

pub fn from(timerspec: TimerSpec) -> Expiration

impl From<Uid> for u32

pub fn from(uid: Uid) -> u32

Loading content...

Implementors

impl From<&'static str> for NodeLabel

pub fn from(value: &'static str) -> NodeLabel

impl From<&'static str> for SlotLabel

pub fn from(value: &'static str) -> SlotLabel

impl From<AssetIoError> for AssetServerError

pub fn from(source: AssetIoError) -> AssetServerError

impl From<RenderGraphError> for StagerError

pub fn from(source: RenderGraphError) -> StagerError

impl From<ErrorKind> for DimensionError

fn from(err: ErrorKind) -> DimensionError

impl From<ErrorKind> for bevy_tilemap::map::MapError

fn from(err: ErrorKind) -> MapError

impl From<[f32; 2]> for Vec2

pub fn from(a: [f32; 2]) -> Vec2

impl From<[f32; 3]> for Vec3A

pub fn from(a: [f32; 3]) -> Vec3A

impl From<[f32; 3]> for Vec3

pub fn from(a: [f32; 3]) -> Vec3

impl From<[f32; 4]> for ColorSource

pub fn from(f32s: [f32; 4]) -> ColorSource

impl From<[f32; 4]> for Quat

pub fn from(a: [f32; 4]) -> Quat

impl From<[f32; 4]> for Vec4

pub fn from(a: [f32; 4]) -> Vec4

impl From<[f32; 4]> for Color

pub fn from([f32; 4]) -> Color

impl From<(f32, f32, f32, f32)> for Quat

pub fn from(t: (f32, f32, f32, f32)) -> Quat

impl From<(f32, f32, f32, f32)> for Vec4

pub fn from(t: (f32, f32, f32, f32)) -> Vec4

impl From<(f32, f32, f32)> for Vec3A

pub fn from(t: (f32, f32, f32)) -> Vec3A

impl From<(f32, f32, f32)> for Vec3

pub fn from(t: (f32, f32, f32)) -> Vec3

impl From<(f32, f32)> for Vec2

pub fn from(t: (f32, f32)) -> Vec2

impl From<usize> for SlotLabel

pub fn from(value: usize) -> SlotLabel

impl From<AssetPathId> for HandleId

pub fn from(value: AssetPathId) -> HandleId

impl From<AssetPathId> for SourcePathId

pub fn from(id: AssetPathId) -> SourcePathId

impl From<MissingComponent> for ComponentError

pub fn from(x: MissingComponent) -> ComponentError

impl From<NoSuchEntity> for ComponentError

pub fn from(NoSuchEntity) -> ComponentError

impl From<Quat> for Vec4

pub fn from(q: Quat) -> Vec4

impl From<Vec3A> for Vec3

pub fn from(v: Vec3A) -> Vec3

impl From<Vec4> for ColorSource

pub fn from(vec4: Vec4) -> ColorSource

impl From<Vec4> for Quat

pub fn from(v: Vec4) -> Quat

impl From<Vec4> for Color

pub fn from(vec4: Vec4) -> Color

impl From<Color> for ColorSource

pub fn from(color: Color) -> ColorSource

impl From<Color> for Vec4

pub fn from(color: Color) -> Vec4

impl From<Color> for ColorMaterial

pub fn from(color: Color) -> ColorMaterial

impl From<Cube> for Mesh

pub fn from(cube: Cube) -> Mesh

impl From<Icosphere> for Mesh

pub fn from(sphere: Icosphere) -> Mesh

impl From<Plane> for Mesh

pub fn from(plane: Plane) -> Mesh

impl From<Quad> for Mesh

pub fn from(quad: Quad) -> Mesh

impl From<NodeId> for NodeLabel

pub fn from(value: NodeId) -> NodeLabel

impl From<BufferId> for RenderResourceId

pub fn from(value: BufferId) -> RenderResourceId

impl From<SamplerId> for RenderResourceId

pub fn from(value: SamplerId) -> RenderResourceId

impl From<TextureId> for RenderResourceId

pub fn from(value: TextureId) -> RenderResourceId

impl From<GlobalTransform> for Transform

pub fn from(transform: GlobalTransform) -> Transform

impl From<Box<str>> for Box<[u8]>

pub fn from(s: Box<str>) -> Box<[u8]>

Converts a Box<str> into a Box<[u8]>

This conversion does not allocate on the heap and happens in place.

Examples

// create a Box<str> which will be used to create a Box<[u8]>
let boxed: Box<str> = Box::from("hello");
let boxed_str: Box<[u8]> = Box::from(boxed);

// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice = Box::from(slice);

assert_eq!(boxed_slice, boxed_str);

impl From<Handle<Texture>> for ColorSource

pub fn from(texture: Handle<Texture>) -> ColorSource

impl From<Handle<Texture>> for ColorMaterial

pub fn from(texture: Handle<Texture>) -> ColorMaterial

impl From<Transform> for GlobalTransform

pub fn from(transform: Transform) -> GlobalTransform

impl From<Vec3> for Vec3A

pub fn from(v: Vec3) -> Vec3A

impl From<Vec<[f32; 2]>> for VertexAttributeValues

pub fn from(vec: Vec<[f32; 2]>) -> VertexAttributeValues

impl From<Vec<[f32; 3]>> for VertexAttributeValues

pub fn from(vec: Vec<[f32; 3]>) -> VertexAttributeValues

impl From<Vec<[f32; 4]>> for VertexAttributeValues

pub fn from(vec: Vec<[f32; 4]>) -> VertexAttributeValues

impl From<Vec<f32>> for VertexAttributeValues

pub fn from(vec: Vec<f32>) -> VertexAttributeValues

impl From<String> for NodeLabel

pub fn from(value: String) -> NodeLabel

impl From<String> for SlotLabel

pub fn from(value: String) -> SlotLabel

impl From<String> for Arc<str>

pub fn from(v: String) -> Arc<str>

impl From<String> for Box<str>

pub fn from(s: String) -> Box<str>

Converts the given String to a boxed str slice that is owned.

Examples

Basic usage:

let s1: String = String::from("hello world");
let s2: Box<str> = Box::from(s1);
let s3: String = String::from(s2);

assert_eq!("hello world", s3)

impl From<String> for Box<dyn Error + 'static + Sync + Send>

pub fn from(err: String) -> Box<dyn Error + 'static + Sync + Send>

Converts a String into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl From<String> for Box<dyn Error + 'static>

pub fn from(str_err: String) -> Box<dyn Error + 'static>

Converts a String into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error>::from(a_string_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl From<String> for Vec<u8>

pub fn from(string: String) -> Vec<u8>

Converts the given String to a vector Vec that holds values of type u8.

Examples

Basic usage:

let s1 = String::from("hello world");
let v1 = Vec::from(s1);

for b in v1 {
    println!("{}", b);
}

impl From<__m128> for Quat

pub fn from(t: __m128) -> Quat

impl From<__m128> for Vec3A

pub fn from(t: __m128) -> Vec3A

impl From<__m128> for Vec4

pub fn from(t: __m128) -> Vec4

impl From<CString> for Arc<CStr>

pub fn from(s: CString) -> Arc<CStr>

Converts a CString into a Arc<CStr> without copying or allocating.

impl From<CString> for Box<CStr>

pub fn from(s: CString) -> Box<CStr>

Converts a CString into a Box<CStr> without copying or allocating.

impl From<CString> for Vec<u8>

pub fn from(s: CString) -> Vec<u8>

Converts a CString into a Vec<u8>.

The conversion consumes the CString, and removes the terminating NUL byte.

impl From<OsString> for Arc<OsStr>

pub fn from(s: OsString) -> Arc<OsStr>

Converts a OsString into a Arc<OsStr> without copying or allocating.

impl From<OsString> for Box<OsStr>

pub fn from(s: OsString) -> Box<OsStr>

Converts a OsString into a Box<OsStr> without copying or allocating.

impl From<Error> for AssetIoError

pub fn from(source: Error) -> AssetIoError

impl From<PathBuf> for Arc<Path>

pub fn from(s: PathBuf) -> Arc<Path>

Converts a PathBuf into an Arc by moving the PathBuf data into a new Arc buffer.

impl From<PathBuf> for Box<Path>

pub fn from(p: PathBuf) -> Box<Path>

Converts a PathBuf into a Box<Path>

This conversion currently should not allocate memory, but this behavior is not guaranteed on all platforms or in all future versions.

impl From<Error> for Box<dyn Error + 'static + Send>

pub fn from(error: Error) -> Box<dyn Error + 'static + Send>

impl From<Error> for Box<dyn Error + 'static + Sync + Send>

pub fn from(error: Error) -> Box<dyn Error + 'static + Sync + Send>

impl From<Error> for Box<dyn Error + 'static>

pub fn from(error: Error) -> Box<dyn Error + 'static>

impl From<Box2D<i32, UnknownUnit>> for bevy_tilemap::Rect

pub fn from(rectangle: Box2D<i32, UnknownUnit>) -> Rect

impl From<StreamResult> for Result<MZStatus, MZError>

pub fn from(res: StreamResult) -> Result<MZStatus, MZError>

impl From<StreamResult> for Result<MZStatus, MZError>

pub fn from(res: StreamResult) -> Result<MZStatus, MZError>

impl<'_> From<&'_ Indices> for IndexFormat

pub fn from(indices: &Indices) -> IndexFormat

impl<'_> From<&'_ VertexAttributeValues> for VertexFormat

pub fn from(values: &VertexAttributeValues) -> VertexFormat

impl<'_> From<&'_ NodeLabel> for NodeLabel

pub fn from(value: &NodeLabel) -> NodeLabel

impl<'_> From<&'_ SlotLabel> for SlotLabel

pub fn from(value: &SlotLabel) -> SlotLabel

impl<'_> From<&'_ str> for HandleId

pub fn from(value: &str) -> HandleId

impl<'_> From<&'_ str> for Arc<str>

pub fn from(v: &str) -> Arc<str>

impl<'_> From<&'_ str> for Box<str>

pub fn from(s: &str) -> Box<str>

Converts a &str into a Box<str>

This conversion allocates on the heap and performs a copy of s.

Examples

let boxed: Box<str> = Box::from("hello");
println!("{}", boxed);

impl<'_> From<&'_ str> for Box<dyn Error + 'static>

pub fn from(err: &str) -> Box<dyn Error + 'static>

Converts a str into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error>::from(a_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'_> From<&'_ str> for Vec<u8>

pub fn from(s: &str) -> Vec<u8>

impl<'_> From<&'_ HandleUntyped> for HandleId

pub fn from(value: &HandleUntyped) -> HandleId

impl<'_> From<&'_ ResourceSlotInfo> for ResourceSlot

pub fn from(slot: &ResourceSlotInfo) -> ResourceSlot

impl<'_> From<&'_ Texture> for TextureDescriptor

pub fn from(texture: &Texture) -> TextureDescriptor

impl<'_> From<&'_ CStr> for Arc<CStr>

pub fn from(s: &CStr) -> Arc<CStr>

impl<'_> From<&'_ CStr> for Box<CStr>

pub fn from(s: &CStr) -> Box<CStr>

impl<'_> From<&'_ OsStr> for Arc<OsStr>

pub fn from(s: &OsStr) -> Arc<OsStr>

impl<'_> From<&'_ OsStr> for Box<OsStr>

pub fn from(s: &OsStr) -> Box<OsStr>

impl<'_> From<&'_ Path> for Arc<Path>

pub fn from(s: &Path) -> Arc<Path>

Converts a Path into an Arc by copying the Path data into a new Arc buffer.

impl<'_> From<&'_ Path> for Box<Path>

pub fn from(path: &Path) -> Box<Path>

impl<'_> From<&'_ StreamResult> for Result<MZStatus, MZError>

pub fn from(res: &StreamResult) -> Result<MZStatus, MZError>

impl<'_> From<&'_ StreamResult> for Result<MZStatus, MZError>

pub fn from(res: &StreamResult) -> Result<MZStatus, MZError>

impl<'_> From<Cow<'_, str>> for Box<str>

pub fn from(cow: Cow<'_, str>) -> Box<str>

impl<'_> From<Cow<'_, CStr>> for Box<CStr>

pub fn from(cow: Cow<'_, CStr>) -> Box<CStr>

impl<'_> From<Cow<'_, OsStr>> for Box<OsStr>

pub fn from(cow: Cow<'_, OsStr>) -> Box<OsStr>

impl<'_> From<Cow<'_, Path>> for Box<Path>

pub fn from(cow: Cow<'_, Path>) -> Box<Path>

impl<'_> From<&'_ [ResourceSlotInfo]> for ResourceSlots

pub fn from(slots: &[ResourceSlotInfo]) -> ResourceSlots

impl<'_, T> From<&'_ Handle<T>> for HandleId

pub fn from(value: &Handle<T>) -> HandleId

impl<'_, T> From<Cow<'_, [T]>> for Box<[T]> where
    T: Copy, 

pub fn from(cow: Cow<'_, [T]>) -> Box<[T]>

impl<'_, T> From<&'_ [T]> for Arc<[T]> where
    T: Clone, 

pub fn from(v: &[T]) -> Arc<[T]>

impl<'_, T> From<&'_ [T]> for Box<[T]> where
    T: Copy, 

pub fn from(slice: &[T]) -> Box<[T]>

Converts a &[T] into a Box<[T]>

This conversion allocates on the heap and performs a copy of slice.

Examples

// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice: Box<[u8]> = Box::from(slice);

println!("{:?}", boxed_slice);

impl<'_, T> From<&'_ [T]> for Vec<T> where
    T: Clone, 

pub fn from(s: &[T]) -> Vec<T>

impl<'_, T> From<&'_ mut [T]> for Vec<T> where
    T: Clone, 

pub fn from(s: &mut [T]) -> Vec<T>

impl<'a> From<&'a str> for AssetPath<'a>

pub fn from(asset_path: &'a str) -> AssetPath<'a>

impl<'a> From<&'a Path> for AssetPath<'a>

pub fn from(path: &'a Path) -> AssetPath<'a>

impl<'a> From<&'a Path> for SourcePathId

pub fn from(value: &'a Path) -> SourcePathId

impl<'a> From<&'a Chmap> for Vec<ChmapPosition>

pub fn from(a: &'a Chmap) -> Vec<ChmapPosition>

impl<'a> From<Option<&'a str>> for LabelId

pub fn from(value: Option<&'a str>) -> LabelId

impl<'a> From<Cow<'a, str>> for Box<dyn Error + 'static>

pub fn from(err: Cow<'a, str>) -> Box<dyn Error + 'static>

Converts a Cow into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a> From<AssetPath<'a>> for HandleId

pub fn from(value: AssetPath<'a>) -> HandleId

impl<'a> From<AssetPath<'a>> for SourcePathId

pub fn from(path: AssetPath<'_>) -> SourcePathId

impl<'a> From<PathBuf> for AssetPath<'a>

pub fn from(path: PathBuf) -> AssetPath<'a>

impl<'a, '_> From<&'_ str> for Box<dyn Error + 'a + Sync + Send>

pub fn from(err: &str) -> Box<dyn Error + 'a + Sync + Send>

Converts a str into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl<'a, 'b> From<&'a AssetPath<'b>> for AssetPathId

pub fn from(asset_path: &'a AssetPath<'b>) -> AssetPathId

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a + Sync + Send>

pub fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a + Sync + Send>

Converts a Cow into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl<'a, B> From<Cow<'a, B>> for Arc<B> where
    B: ToOwned + ?Sized,
    Arc<B>: From<&'a B>,
    Arc<B>: From<<B as ToOwned>::Owned>, 

pub fn from(cow: Cow<'a, B>) -> Arc<B>

impl<'a, E> From<E> for Box<dyn Error + 'a + Sync + Send> where
    E: 'a + Error + Send + Sync, 

pub fn from(err: E) -> Box<dyn Error + 'a + Sync + Send>

Converts a type of Error + Send + Sync into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::fmt;
use std::mem;

#[derive(Debug)]
struct AnError;

impl fmt::Display for AnError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f , "An error")
    }
}

impl Error for AnError {}

unsafe impl Send for AnError {}

unsafe impl Sync for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl<'a, E> From<E> for Box<dyn Error + 'a> where
    E: 'a + Error, 

pub fn from(err: E) -> Box<dyn Error + 'a>

Converts a type of Error into a box of dyn Error.

Examples

use std::error::Error;
use std::fmt;
use std::mem;

#[derive(Debug)]
struct AnError;

impl fmt::Display for AnError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f , "An error")
    }
}

impl Error for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a, T> From<&'a Option<T>> for Option<&'a T>

pub fn from(o: &'a Option<T>) -> Option<&'a T>

Converts from &Option<T> to Option<&T>.

Examples

Converts an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let s: Option<String> = Some(String::from("Hello, Rustaceans!"));
let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len());

println!("Can still print s: {:?}", s);

assert_eq!(o, Some(18));

impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>

pub fn from(o: &'a mut Option<T>) -> Option<&'a mut T>

Converts from &mut Option<T> to Option<&mut T>

Examples

let mut s = Some(String::from("Hello"));
let o: Option<&mut String> = Option::from(&mut s);

match o {
    Some(t) => *t = String::from("Hello, Rustaceans!"),
    None => (),
}

assert_eq!(s, Some(String::from("Hello, Rustaceans!")));

impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where
    [T]: ToOwned,
    <[T] as ToOwned>::Owned == Vec<T>, 

pub fn from(s: Cow<'a, [T]>) -> Vec<T>

impl<'a, T> From<T> for AssetPathId where
    T: Into<AssetPath<'a>>, 

pub fn from(value: T) -> AssetPathId

impl<T> From<!> for T

Stability note: This impl does not yet exist, but we are "reserving space" to add it in the future. See rust-lang/rust#64715 for details.

pub fn from(t: !) -> T

impl<T> From<Box<[T]>> for Vec<T>

pub fn from(s: Box<[T]>) -> Vec<T>

impl<T> From<Box<T>> for Arc<T> where
    T: ?Sized, 

pub fn from(v: Box<T>) -> Arc<T>

impl<T> From<Handle<T>> for HandleId

pub fn from(value: Handle<T>) -> HandleId

impl<T> From<Vec<T>> for Arc<[T]>

pub fn from(v: Vec<T>) -> Arc<[T]>

impl<T> From<Vec<T>> for Box<[T]>

pub fn from(v: Vec<T>) -> Box<[T]>

impl<T> From<BinaryHeap<T>> for Vec<T>

pub fn from(heap: BinaryHeap<T>) -> Vec<T>

Converts a BinaryHeap<T> into a Vec<T>.

This conversion requires no data movement or allocation, and has constant time complexity.

impl<T> From<VecDeque<T>> for Vec<T>

pub fn from(other: VecDeque<T>) -> Vec<T>

Turn a VecDeque<T> into a Vec<T>.

This never needs to re-allocate, but does need to do O(n) data movement if the circular buffer doesn't happen to be at the beginning of the allocation.

Examples

use std::collections::VecDeque;

// This one is *O*(1).
let deque: VecDeque<_> = (1..5).collect();
let ptr = deque.as_slices().0.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);

// This one needs data rearranging.
let mut deque: VecDeque<_> = (1..5).collect();
deque.push_front(9);
deque.push_front(8);
let ptr = deque.as_slices().1.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [8, 9, 1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);

impl<T> From<T> for Option<T>

pub fn from(val: T) -> Option<T>

Copies val into a new Some.

Examples

let o: Option<u8> = Option::from(67);

assert_eq!(Some(67), o);

impl<T> From<T> for bevy_tilemap::bevy_render::once_cell::sync::OnceCell<T>

pub fn from(value: T) -> OnceCell<T>

impl<T> From<T> for bevy_tilemap::bevy_render::once_cell::unsync::OnceCell<T>

pub fn from(value: T) -> OnceCell<T>

impl<T> From<T> for Arc<T>

pub fn from(t: T) -> Arc<T>

impl<T> From<T> for Box<T>

pub fn from(t: T) -> Box<T>

Converts a generic type T into a Box<T>

The conversion allocates on the heap and moves t from the stack into it.

Examples

let x = 5;
let boxed = Box::new(5);

assert_eq!(Box::from(x), boxed);

impl<T> From<T> for bevy_tilemap::Mutex<T>

pub fn from(t: T) -> Mutex<T>

Creates a new mutex in an unlocked state ready for use. This is equivalent to Mutex::new.

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T, const N: usize> From<[T; N]> for Box<[T]>

pub fn from(array: [T; N]) -> Box<[T]>

Converts a [T; N] into a Box<[T]>

This conversion moves the array to newly heap-allocated memory.

Examples

let boxed: Box<[u8]> = Box::from([4, 2]);
println!("{:?}", boxed);

impl<T, const N: usize> From<[T; N]> for Vec<T>

pub fn from(s: [T; N]) -> Vec<T>

Loading content...