Trait wasmtime_wiggle::bitflags::_core::str::FromStr

pub trait FromStr {
    type Err;
    fn from_str(s: &str) -> Result<Self, Self::Err>;
}

Parse a value from a string

FromStr’s from_str method is often used implicitly, through str’s parse method. See parse’s documentation for examples.

FromStr does not have a lifetime parameter, and so you can only parse types that do not contain a lifetime parameter themselves. In other words, you can parse an i32 with FromStr, but not a &i32. You can parse a struct that contains an i32, but not one that contains an &i32.

Examples

Basic implementation of FromStr on an example Point type:

use std::str::FromStr;
use std::num::ParseIntError;

#[derive(Debug, PartialEq)]
struct Point {
    x: i32,
    y: i32
}

impl FromStr for Point {
    type Err = ParseIntError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let coords: Vec<&str> = s.trim_matches(|p| p == '(' || p == ')' )
                                 .split(',')
                                 .collect();

        let x_fromstr = coords[0].parse::<i32>()?;
        let y_fromstr = coords[1].parse::<i32>()?;

        Ok(Point { x: x_fromstr, y: y_fromstr })
    }
}

let p = Point::from_str("(1,2)");
assert_eq!(p.unwrap(), Point{ x: 1, y: 2} )

Associated Types

type Err

The associated error which can be returned from parsing.

Required methods

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

If parsing succeeds, return the value inside Ok, otherwise when the string is ill-formatted return an error specific to the inside Err. The error type is specific to implementation of the trait.

Examples

Basic usage with i32, a type that implements FromStr:

use std::str::FromStr;

let s = "5";
let x = i32::from_str(s).unwrap();

assert_eq!(5, x);

Implementations on Foreign Types

impl FromStr for Ipv6Addr

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError>

impl FromStr for SocketAddrV4

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<SocketAddrV4, AddrParseError>

impl FromStr for IpAddr

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<IpAddr, AddrParseError>

impl FromStr for PathBuf

type Err = Infallible

pub fn from_str(s: &str) -> Result<PathBuf, <PathBuf as FromStr>::Err>

impl FromStr for SocketAddr

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<SocketAddr, AddrParseError>

impl FromStr for Ipv4Addr

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError>

impl FromStr for OsString

type Err = Infallible

pub fn from_str(s: &str) -> Result<OsString, <OsString as FromStr>::Err>

impl FromStr for SocketAddrV6

type Err = AddrParseError

pub fn from_str(s: &str) -> Result<SocketAddrV6, AddrParseError>

impl FromStr for f64

pub fn from_str(src: &str) -> Result<f64, ParseFloatError>

Converts a string in base 10 to a float. Accepts an optional decimal exponent.

This function accepts strings such as

• ‘3.14’
• ‘-3.14’
• ‘2.5E10’, or equivalently, ‘2.5e10’
• ‘2.5E-10’
• ‘5.’
• ‘.5’, or, equivalently, ‘0.5’
• ‘inf’, ‘-inf’, ‘NaN’

Leading and trailing whitespace represent an error.

Grammar

All strings that adhere to the following EBNF grammar will result in an Ok being returned:

Float  ::= Sign? ( 'inf' | 'NaN' | Number )
Number ::= ( Digit+ |
             Digit+ '.' Digit* |
             Digit* '.' Digit+ ) Exp?
Exp    ::= [eE] Sign? Digit+
Sign   ::= [+-]
Digit  ::= [0-9]

Known bugs

In some situations, some strings that should create a valid float instead return an error. See issue #31407 for details.

Arguments

• src - A string

Return value

Err(ParseFloatError) if the string did not represent a valid number. Otherwise, Ok(n) where n is the floating-point number represented by src.

type Err = ParseFloatError

impl FromStr for char

type Err = ParseCharError

pub fn from_str(s: &str) -> Result<char, <char as FromStr>::Err>

impl FromStr for i8

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i8, ParseIntError>

impl FromStr for u16

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u16, ParseIntError>

impl FromStr for u64

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u64, ParseIntError>

impl FromStr for usize

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<usize, ParseIntError>

impl FromStr for bool

pub fn from_str(s: &str) -> Result<bool, ParseBoolError>

Parse a bool from a string.

Yields a Result<bool, ParseBoolError>, because s may or may not actually be parseable.

Examples

use std::str::FromStr;

assert_eq!(FromStr::from_str("true"), Ok(true));
assert_eq!(FromStr::from_str("false"), Ok(false));
assert!(<bool as FromStr>::from_str("not even a boolean").is_err());

Note, in many cases, the .parse() method on str is more proper.

assert_eq!("true".parse(), Ok(true));
assert_eq!("false".parse(), Ok(false));
assert!("not even a boolean".parse::<bool>().is_err());

type Err = ParseBoolError

impl FromStr for i64

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i64, ParseIntError>

impl FromStr for u8

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u8, ParseIntError>

impl FromStr for isize

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<isize, ParseIntError>

impl FromStr for f32

pub fn from_str(src: &str) -> Result<f32, ParseFloatError>

Converts a string in base 10 to a float. Accepts an optional decimal exponent.

This function accepts strings such as

• ‘3.14’
• ‘-3.14’
• ‘2.5E10’, or equivalently, ‘2.5e10’
• ‘2.5E-10’
• ‘5.’
• ‘.5’, or, equivalently, ‘0.5’
• ‘inf’, ‘-inf’, ‘NaN’

Leading and trailing whitespace represent an error.

Grammar

All strings that adhere to the following EBNF grammar will result in an Ok being returned:

Float  ::= Sign? ( 'inf' | 'NaN' | Number )
Number ::= ( Digit+ |
             Digit+ '.' Digit* |
             Digit* '.' Digit+ ) Exp?
Exp    ::= [eE] Sign? Digit+
Sign   ::= [+-]
Digit  ::= [0-9]

Known bugs

In some situations, some strings that should create a valid float instead return an error. See issue #31407 for details.

Arguments

• src - A string

Return value

Err(ParseFloatError) if the string did not represent a valid number. Otherwise, Ok(n) where n is the floating-point number represented by src.

type Err = ParseFloatError

impl FromStr for i16

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i16, ParseIntError>

impl FromStr for u128

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u128, ParseIntError>

impl FromStr for u32

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<u32, ParseIntError>

impl FromStr for i32

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i32, ParseIntError>

impl FromStr for i128

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<i128, ParseIntError>

impl FromStr for String

type Err = Infallible

pub fn from_str(s: &str) -> Result<String, <String as FromStr>::Err>

impl FromStr for Level

type Err = ParseLevelError

pub fn from_str(level: &str) -> Result<Level, <Level as FromStr>::Err>

impl FromStr for LevelFilter

type Err = ParseLevelError

pub fn from_str(
    level: &str
) -> Result<LevelFilter, <LevelFilter as FromStr>::Err>

impl FromStr for Offset32

type Err = &'static str

pub fn from_str(s: &str) -> Result<Offset32, &'static str>

impl FromStr for LibCall

type Err = ()

pub fn from_str(s: &str) -> Result<LibCall, <LibCall as FromStr>::Err>

impl FromStr for LibcallCallConv

type Err = ()

pub fn from_str(
    s: &str
) -> Result<LibcallCallConv, <LibcallCallConv as FromStr>::Err>

impl FromStr for Imm64

type Err = &'static str

pub fn from_str(s: &str) -> Result<Imm64, &'static str>

impl FromStr for Uimm32

type Err = &'static str

pub fn from_str(s: &str) -> Result<Uimm32, &'static str>

impl FromStr for CallConv

type Err = ()

pub fn from_str(s: &str) -> Result<CallConv, <CallConv as FromStr>::Err>

impl FromStr for TlsModel

type Err = ()

pub fn from_str(s: &str) -> Result<TlsModel, <TlsModel as FromStr>::Err>

impl FromStr for Ieee32

type Err = &'static str

pub fn from_str(s: &str) -> Result<Ieee32, &'static str>

impl FromStr for ArgumentPurpose

type Err = ()

pub fn from_str(s: &str) -> Result<ArgumentPurpose, ()>

impl FromStr for Opcode

pub fn from_str(s: &str) -> Result<Opcode, &'static str>

Parse an Opcode name from a string.

type Err = &'static str

impl FromStr for TrapCode

type Err = ()

pub fn from_str(s: &str) -> Result<TrapCode, <TrapCode as FromStr>::Err>

impl FromStr for AtomicRmwOp

type Err = ()

pub fn from_str(s: &str) -> Result<AtomicRmwOp, <AtomicRmwOp as FromStr>::Err>

impl FromStr for Uimm64

type Err = &'static str

pub fn from_str(s: &str) -> Result<Uimm64, &'static str>

impl FromStr for Regalloc

type Err = ()

pub fn from_str(s: &str) -> Result<Regalloc, <Regalloc as FromStr>::Err>

impl FromStr for StackSlotKind

type Err = ()

pub fn from_str(s: &str) -> Result<StackSlotKind, ()>

impl FromStr for OptLevel

type Err = ()

pub fn from_str(s: &str) -> Result<OptLevel, <OptLevel as FromStr>::Err>

impl FromStr for Ieee64

type Err = &'static str

pub fn from_str(s: &str) -> Result<Ieee64, &'static str>

impl FromStr for ExternalName

type Err = ()

pub fn from_str(s: &str) -> Result<ExternalName, <ExternalName as FromStr>::Err>

impl FromStr for ConstantData

pub fn from_str(s: &str) -> Result<ConstantData, &'static str>

Parse a hexadecimal string to ConstantData. This is the inverse of Display::fmt.

use cranelift_codegen::ir::ConstantData;
let c: ConstantData = "0x000102".parse().unwrap();
assert_eq!(c.into_vec(), [2, 1, 0]);

type Err = &'static str

impl FromStr for FloatCC

type Err = ()

pub fn from_str(s: &str) -> Result<FloatCC, <FloatCC as FromStr>::Err>

impl FromStr for IntCC

type Err = ()

pub fn from_str(s: &str) -> Result<IntCC, <IntCC as FromStr>::Err>

impl FromStr for Architecture

type Err = ()

pub fn from_str(s: &str) -> Result<Architecture, ()>

impl FromStr for Mips32Architecture

type Err = ()

pub fn from_str(s: &str) -> Result<Mips32Architecture, ()>

impl FromStr for Triple

type Err = ParseError

pub fn from_str(s: &str) -> Result<Triple, <Triple as FromStr>::Err>

impl FromStr for Aarch64Architecture

type Err = ()

pub fn from_str(s: &str) -> Result<Aarch64Architecture, ()>

impl FromStr for Riscv64Architecture

type Err = ()

pub fn from_str(s: &str) -> Result<Riscv64Architecture, ()>

impl FromStr for Riscv32Architecture

type Err = ()

pub fn from_str(s: &str) -> Result<Riscv32Architecture, ()>

impl FromStr for Environment

type Err = ()

pub fn from_str(s: &str) -> Result<Environment, ()>

impl FromStr for Mips64Architecture

type Err = ()

pub fn from_str(s: &str) -> Result<Mips64Architecture, ()>

impl FromStr for Vendor

type Err = ()

pub fn from_str(s: &str) -> Result<Vendor, ()>

impl FromStr for OperatingSystem

type Err = ()

pub fn from_str(s: &str) -> Result<OperatingSystem, ()>

impl FromStr for ArmArchitecture

type Err = ()

pub fn from_str(s: &str) -> Result<ArmArchitecture, ()>

impl FromStr for X86_32Architecture

type Err = ()

pub fn from_str(s: &str) -> Result<X86_32Architecture, ()>

impl FromStr for BinaryFormat

type Err = ()

pub fn from_str(s: &str) -> Result<BinaryFormat, ()>

Implementors

impl FromStr for wasmtime_wiggle::tracing::metadata::LevelFilter

type Err = ParseLevelFilterError

pub fn from_str(
    from: &str
) -> Result<LevelFilter, <LevelFilter as FromStr>::Err>

impl FromStr for wasmtime_wiggle::tracing::Level

type Err = ParseLevelError

pub fn from_str(s: &str) -> Result<Level, ParseLevelError>

impl FromStr for NonZeroI8

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI8, <NonZeroI8 as FromStr>::Err>

impl FromStr for NonZeroI16

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI16, <NonZeroI16 as FromStr>::Err>

impl FromStr for NonZeroI32

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI32, <NonZeroI32 as FromStr>::Err>

impl FromStr for NonZeroI64

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI64, <NonZeroI64 as FromStr>::Err>

impl FromStr for NonZeroI128

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroI128, <NonZeroI128 as FromStr>::Err>

impl FromStr for NonZeroIsize

type Err = ParseIntError

pub fn from_str(
    src: &str
) -> Result<NonZeroIsize, <NonZeroIsize as FromStr>::Err>

impl FromStr for NonZeroU8

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU8, <NonZeroU8 as FromStr>::Err>

impl FromStr for NonZeroU16

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU16, <NonZeroU16 as FromStr>::Err>

impl FromStr for NonZeroU32

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU32, <NonZeroU32 as FromStr>::Err>

impl FromStr for NonZeroU64

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU64, <NonZeroU64 as FromStr>::Err>

impl FromStr for NonZeroU128

type Err = ParseIntError

pub fn from_str(src: &str) -> Result<NonZeroU128, <NonZeroU128 as FromStr>::Err>

impl FromStr for NonZeroUsize

type Err = ParseIntError

pub fn from_str(
    src: &str
) -> Result<NonZeroUsize, <NonZeroUsize as FromStr>::Err>