Trait artifact_app::dev_prefix::FromStr

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

A trait to abstract the idea of creating a new instance of a type from a string.

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

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 Json

type Err = ParserError

fn from_str(s: &str) -> Result<Json, ParserError>

impl FromStr for Value

type Err = Error

fn from_str(s: &str) -> Result<Value, Error>

impl FromStr for i32

type Err = ParseIntError

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

impl FromStr for bool

type Err = ParseBoolError

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());

impl FromStr for char

type Err = ParseCharError

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

impl FromStr for f32

type Err = ParseFloatError

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.

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.

impl FromStr for u64

type Err = ParseIntError

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

impl FromStr for u8

type Err = ParseIntError

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

impl FromStr for i16

type Err = ParseIntError

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

impl FromStr for u16

type Err = ParseIntError

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

impl FromStr for isize

type Err = ParseIntError

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

impl FromStr for f64

type Err = ParseFloatError

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.

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.

impl FromStr for u128

type Err = ParseIntError

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

impl FromStr for i8

type Err = ParseIntError

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

impl FromStr for i64

type Err = ParseIntError

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

impl FromStr for i128

type Err = ParseIntError

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

impl FromStr for usize

type Err = ParseIntError

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

impl FromStr for u32

type Err = ParseIntError

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

impl FromStr for Uuid

type Err = ParseError

fn from_str(us: &str) -> Result<Uuid, ParseError>

Parse a hex string and interpret as a Uuid.

Accepted formats are a sequence of 32 hexadecimal characters, with or without hyphens (grouped as 8, 4, 4, 4, 12).

impl<S> FromStr for UniCase<S> where
    S: FromStr, 

type Err = <S as FromStr>::Err

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

impl FromStr for String

type Err = ParseError

fn from_str(s: &str) -> Result<String, ParseError>

impl FromStr for LanguageTag

type Err = Error

fn from_str(s: &str) -> Result<LanguageTag, Error>

impl FromStr for Op

type Err = String

fn from_str(s: &str) -> Result<Op, String>

impl FromStr for Regex

type Err = Error

fn from_str(s: &str) -> Result<Regex, Error>

Attempts to parse a string into a regular expression

impl FromStr for MediaType

type Err = &'static str

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

impl FromStr for LogLevel

type Err = ()

fn from_str(level: &str) -> Result<LogLevel, ()>

impl FromStr for LogLevelFilter

type Err = ()

fn from_str(level: &str) -> Result<LogLevelFilter, ()>

impl<S> FromStr for UniCase<S> where
    S: AsRef<str> + FromStr, 

type Err = <S as FromStr>::Err

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

impl<S> FromStr for Ascii<S> where
    S: FromStr, 

type Err = <S as FromStr>::Err

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

impl FromStr for Ipv6Addr

type Err = AddrParseError

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

impl FromStr for SocketAddrV6

type Err = AddrParseError

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

impl FromStr for SocketAddrV4

type Err = AddrParseError

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

impl FromStr for Ipv4Addr

type Err = AddrParseError

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

impl FromStr for SocketAddr

type Err = AddrParseError

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

impl FromStr for IpAddr

type Err = AddrParseError

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

impl FromStr for Datetime

type Err = DatetimeParseError

fn from_str(date: &str) -> Result<Datetime, DatetimeParseError>

impl FromStr for Value

type Err = Error

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

impl FromStr for ConnectionOption

type Err = ()

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

impl FromStr for ProtocolName

type Err = ()

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

impl FromStr for Basic

type Err = Error

fn from_str(s: &str) -> Result<Basic, Error>

impl FromStr for Host

type Err = Error

fn from_str(s: &str) -> Result<Host, Error>

impl FromStr for Bearer

type Err = Error

fn from_str(s: &str) -> Result<Bearer, Error>

impl FromStr for Charset

type Err = Error

fn from_str(s: &str) -> Result<Charset, Error>

impl FromStr for Protocol

type Err = ()

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

impl FromStr for CacheDirective

type Err = Option<<u32 as FromStr>::Err>

fn from_str(s: &str) -> Result<CacheDirective, Option<<u32 as FromStr>::Err>>

impl FromStr for MediaDesc

type Err = Error

fn from_str(s: &str) -> Result<MediaDesc, Error>

impl FromStr for Preference

type Err = Option<<u32 as FromStr>::Err>

fn from_str(s: &str) -> Result<Preference, Option<<u32 as FromStr>::Err>>

impl FromStr for ContentRangeSpec

type Err = Error

fn from_str(s: &str) -> Result<ContentRangeSpec, Error>

impl FromStr for RangeUnit

type Err = Error

fn from_str(s: &str) -> Result<RangeUnit, Error>

impl FromStr for StrictTransportSecurity

type Err = Error

fn from_str(s: &str) -> Result<StrictTransportSecurity, Error>

impl FromStr for RelationType

type Err = Error

fn from_str(s: &str) -> Result<RelationType, Error>

impl FromStr for EntityTag

type Err = Error

fn from_str(s: &str) -> Result<EntityTag, Error>

impl FromStr for Encoding

type Err = Error

fn from_str(s: &str) -> Result<Encoding, Error>

impl FromStr for HttpVersion

type Err = Error

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

impl<T> FromStr for QualityItem<T> where
    T: FromStr, 

type Err = Error

fn from_str(s: &str) -> Result<QualityItem<T>, Error>

impl FromStr for Method

type Err = Error

fn from_str(s: &str) -> Result<Method, Error>

impl FromStr for HttpDate

type Err = Error

fn from_str(s: &str) -> Result<HttpDate, Error>

impl FromStr for Link

type Err = Error

fn from_str(s: &str) -> Result<Link, Error>

impl FromStr for ByteRangeSpec

type Err = Error

fn from_str(s: &str) -> Result<ByteRangeSpec, Error>

impl FromStr for Range

type Err = Error

fn from_str(s: &str) -> Result<Range, Error>

impl FromStr for RequestUri

type Err = Error

fn from_str(s: &str) -> Result<RequestUri, Error>

impl FromStr for Origin

type Err = Error

fn from_str(s: &str) -> Result<Origin, Error>

impl FromStr for CFString

type Err = ()

fn from_str(string: &str) -> Result<CFString, ()>

See also CFString::new for a variant of this which does not return a Result

impl FromStr for VersionReq

type Err = ReqParseError

fn from_str(s: &str) -> Result<VersionReq, ReqParseError>

impl FromStr for Version

type Err = SemVerError

fn from_str(s: &str) -> Result<Version, SemVerError>

impl<T> FromStr for QualityItem<T> where
    T: FromStr, 

type Err = Error

fn from_str(s: &str) -> Result<QualityItem<T>, Error>

impl FromStr for Basic

type Err = Error

fn from_str(s: &str) -> Result<Basic, Error>

impl FromStr for ConnectionOption

type Err = ()

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

impl FromStr for Uri

type Err = UriError

fn from_str(s: &str) -> Result<Uri, UriError>

impl FromStr for Preference

type Err = Option<<u32 as FromStr>::Err>

fn from_str(s: &str) -> Result<Preference, Option<<u32 as FromStr>::Err>>

impl FromStr for Origin

type Err = Error

fn from_str(s: &str) -> Result<Origin, Error>

impl FromStr for Encoding

type Err = Error

fn from_str(s: &str) -> Result<Encoding, Error>

impl FromStr for ProtocolName

type Err = ()

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

impl FromStr for Range

type Err = Error

fn from_str(s: &str) -> Result<Range, Error>

impl FromStr for RelationType

type Err = Error

fn from_str(s: &str) -> Result<RelationType, Error>

impl FromStr for Bearer

type Err = Error

fn from_str(s: &str) -> Result<Bearer, Error>

impl FromStr for ByteRangeSpec

type Err = Error

fn from_str(s: &str) -> Result<ByteRangeSpec, Error>

impl FromStr for Charset

type Err = Error

fn from_str(s: &str) -> Result<Charset, Error>

impl FromStr for EntityTag

type Err = Error

fn from_str(s: &str) -> Result<EntityTag, Error>

impl FromStr for HttpVersion

type Err = Error

fn from_str(s: &str) -> Result<HttpVersion, Error>

impl FromStr for Link

type Err = Error

fn from_str(s: &str) -> Result<Link, Error>

impl FromStr for StrictTransportSecurity

type Err = Error

fn from_str(s: &str) -> Result<StrictTransportSecurity, Error>

impl FromStr for ContentRangeSpec

type Err = Error

fn from_str(s: &str) -> Result<ContentRangeSpec, Error>

impl FromStr for Method

type Err = Error

fn from_str(s: &str) -> Result<Method, Error>

impl FromStr for HttpDate

type Err = Error

fn from_str(s: &str) -> Result<HttpDate, Error>

impl FromStr for RangeUnit

type Err = Error

fn from_str(s: &str) -> Result<RangeUnit, Error>

impl FromStr for Protocol

type Err = ()

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

impl FromStr for CacheDirective

type Err = Option<<u32 as FromStr>::Err>

fn from_str(s: &str) -> Result<CacheDirective, Option<<u32 as FromStr>::Err>>

impl FromStr for Warning

type Err = Error

fn from_str(s: &str) -> Result<Warning, Error>

impl FromStr for MediaDesc

type Err = Error

fn from_str(s: &str) -> Result<MediaDesc, Error>

impl FromStr for Host

type Err = Error

fn from_str(s: &str) -> Result<Host, Error>

impl FromStr for Mime

type Err = FromStrError

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

impl FromStr for Value

type Err = ()

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

impl FromStr for Attr

type Err = ()

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

impl FromStr for Mime<Vec<(Attr, Value)>>

type Err = ()

fn from_str(raw: &str) -> Result<Mime<Vec<(Attr, Value)>>, ()>

impl FromStr for TopLevel

type Err = ()

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

impl FromStr for SubLevel

type Err = ()

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

impl FromStr for AppSettings

type Err = String

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

impl FromStr for ArgSettings

type Err = String

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

impl FromStr for Shell

type Err = String

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

impl FromStr for Url

Parse a string as an URL, without a base URL or encoding override.

type Err = ParseError

fn from_str(input: &str) -> Result<Url, ParseError>

Implementors

• impl FromStr for artifact_app::dev_prefix::Regex type Err = Error;
• impl FromStr for Name type Err = Error;
• impl FromStr for SearchSettings type Err = Error;