Trait rustsec::package::checksum::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.

Loading content...

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

Loading content...

Implementations on Foreign Types

impl FromStr for Ipv4Addr

type Err = AddrParseError

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

impl FromStr for PathBuf

type Err = Infallible

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

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 Ipv6Addr

type Err = AddrParseError

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

impl FromStr for SocketAddrV4

type Err = AddrParseError

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

impl FromStr for SocketAddrV6

type Err = AddrParseError

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

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 NonZeroU8

type Err = ParseIntError

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

impl FromStr for NonZeroI8

type Err = ParseIntError

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

impl FromStr for i8

type Err = ParseIntError

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

impl FromStr for u32

type Err = ParseIntError

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

impl FromStr for NonZeroU128

type Err = ParseIntError

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

impl FromStr for NonZeroI32

type Err = ParseIntError

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

impl FromStr for NonZeroI64

type Err = ParseIntError

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

impl FromStr for NonZeroU64

type Err = ParseIntError

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

impl FromStr for NonZeroU32

type Err = ParseIntError

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

impl FromStr for isize

type Err = ParseIntError

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

impl FromStr for NonZeroI128

type Err = ParseIntError

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

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.

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.

impl FromStr for NonZeroIsize

type Err = ParseIntError

fn from_str(src: &str) -> Result<NonZeroIsize, <NonZeroIsize 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.

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.

impl FromStr for u16

type Err = ParseIntError

fn from_str(src: &str) -> Result<u16, 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 NonZeroI16

type Err = ParseIntError

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

impl FromStr for i128

type Err = ParseIntError

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

impl FromStr for NonZeroUsize

type Err = ParseIntError

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

impl FromStr for usize

type Err = ParseIntError

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

impl FromStr for u64

type Err = ParseIntError

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

impl FromStr for i32

type Err = ParseIntError

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

impl FromStr for char

type Err = ParseCharError

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

impl FromStr for i64

type Err = ParseIntError

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

impl FromStr for NonZeroU16

type Err = ParseIntError

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

impl FromStr for u128

type Err = ParseIntError

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

impl FromStr for String

type Err = Infallible

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

impl FromStr for DateTime<Utc>

type Err = ParseError

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

impl FromStr for NaiveTime

Parsing a str into a NaiveTime uses the same format, %H:%M:%S%.f, as in Debug and Display.

Example

use chrono::NaiveTime;

let t = NaiveTime::from_hms(23, 56, 4);
assert_eq!("23:56:04".parse::<NaiveTime>(), Ok(t));

let t = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
assert_eq!("23:56:4.012345678".parse::<NaiveTime>(), Ok(t));

let t = NaiveTime::from_hms_nano(23, 59, 59, 1_234_567_890); // leap second
assert_eq!("23:59:60.23456789".parse::<NaiveTime>(), Ok(t));

assert!("foo".parse::<NaiveTime>().is_err());

type Err = ParseError

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

impl FromStr for NaiveDateTime

Parsing a str into a NaiveDateTime uses the same format, %Y-%m-%dT%H:%M:%S%.f, as in Debug.

Example

use chrono::{NaiveDateTime, NaiveDate};

let dt = NaiveDate::from_ymd(2015, 9, 18).and_hms(23, 56, 4);
assert_eq!("2015-09-18T23:56:04".parse::<NaiveDateTime>(), Ok(dt));

let dt = NaiveDate::from_ymd(12345, 6, 7).and_hms_milli(7, 59, 59, 1_500); // leap second
assert_eq!("+12345-6-7T7:59:60.5".parse::<NaiveDateTime>(), Ok(dt));

assert!("foo".parse::<NaiveDateTime>().is_err());

type Err = ParseError

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

impl FromStr for DateTime<FixedOffset>

type Err = ParseError

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

impl FromStr for DateTime<Local>

type Err = ParseError

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

impl FromStr for NaiveDate

Parsing a str into a NaiveDate uses the same format, %Y-%m-%d, as in Debug and Display.

Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd(2015, 9, 18);
assert_eq!("2015-09-18".parse::<NaiveDate>(), Ok(d));

let d = NaiveDate::from_ymd(12345, 6, 7);
assert_eq!("+12345-6-7".parse::<NaiveDate>(), Ok(d));

assert!("foo".parse::<NaiveDate>().is_err());

type Err = ParseError

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

impl FromStr for Weekday

Parsing a str into a Weekday uses the format %W.

Example

use chrono::Weekday;

assert_eq!("Sunday".parse::<Weekday>(), Ok(Weekday::Sun));
assert!("any day".parse::<Weekday>().is_err());

The parsing is case-insensitive.

assert_eq!("mON".parse::<Weekday>(), Ok(Weekday::Mon));

Only the shortest form (e.g. sun) and the longest form (e.g. sunday) is accepted.

assert!("thurs".parse::<Weekday>().is_err());

type Err = ParseWeekdayError

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

impl FromStr for Oid

type Err = Error

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

Parse a hex-formatted object id into an Oid structure.

Errors

Returns an error if the string is empty, is longer than 40 hex characters, or contains any non-hex characters.

impl FromStr for Level

type Err = ParseLevelError

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

impl FromStr for LevelFilter

type Err = ParseLevelError

fn from_str(level: &str) -> Result<LevelFilter, <LevelFilter 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>

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 PrivilegesRequired

type Err = Error

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

impl FromStr for UserInteraction

type Err = Error

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

impl FromStr for Availability

type Err = Error

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

impl FromStr for Integrity

type Err = Error

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

impl FromStr for Scope

type Err = Error

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

impl FromStr for Base

type Err = Error

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

impl FromStr for AttackComplexity

type Err = Error

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

impl FromStr for AttackVector

type Err = Error

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

impl FromStr for Confidentiality

type Err = Error

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

impl FromStr for VersionReq

type Err = ReqParseError

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

impl FromStr for Op

type Err = String

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

impl FromStr for Op

type Err = String

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

impl FromStr for Key

type Err = Error

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

impl FromStr for Value

type Err = Error

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

impl FromStr for PlatformReq

type Err = Error

fn from_str(req_str: &str) -> Result<PlatformReq, <PlatformReq as FromStr>::Err>

Create a new platform requirement. Platforms support glob-like wildcards on the beginning and end, e.g. *windows*.

Must match at least one known Rust platform "target triple" (e.g. x86_64-unknown-linux-gnu) to be considered valid.

impl FromStr for OS

type Err = Error

fn from_str(os_name: &str) -> Result<OS, <OS as FromStr>::Err>

Create a new Env from the given string

impl FromStr for Arch

type Err = Error

fn from_str(arch_name: &str) -> Result<Arch, <Arch as FromStr>::Err>

Create a new Arch from the given string

impl FromStr for Env

type Err = Error

fn from_str(env_name: &str) -> Result<Env, <Env as FromStr>::Err>

Create a new Env from the given string

impl FromStr for Manifest

type Err = Error

fn from_str(input: &str) -> Result<Manifest, <Manifest as FromStr>::Err>

Read manifest data from string

impl FromStr for Document

type Err = TomlError

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

Parses a document from a &str

impl FromStr for Key

type Err = TomlError

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

Tries to parse a key from a &str, if fails, tries as basic quoted key (surrounds with "") and then literal quoted key (surrounds with '')

impl FromStr for Value

type Err = TomlError

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

Parses a value from a &str

impl FromStr for AsciiString

type Err = AsAsciiStrError

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

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 Regex

type Err = Error

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

Attempts to parse a string into a regular expression

impl FromStr for Uri

type Err = InvalidUri

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

impl FromStr for StatusCode

type Err = InvalidStatusCode

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

impl FromStr for Method

type Err = InvalidMethod

fn from_str(t: &str) -> Result<Method, <Method as FromStr>::Err>

impl FromStr for HeaderName

type Err = InvalidHeaderName

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

impl FromStr for Scheme

type Err = InvalidUri

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

impl FromStr for Authority

type Err = InvalidUri

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

impl FromStr for PathAndQuery

type Err = InvalidUri

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

impl FromStr for HeaderValue

type Err = InvalidHeaderValue

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

impl FromStr for Name

type Err = InvalidNameError

fn from_str(host: &str) -> Result<Name, <Name as FromStr>::Err>

impl FromStr for Mime

type Err = FromStrError

fn from_str(s: &str) -> Result<Mime, <Mime 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<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 FromStr for Color

type Err = ParseColorError

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

impl FromStr for Number

type Err = Error

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

impl FromStr for Value

type Err = Error

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

impl FromStr for Pattern

type Err = PatternError

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

Loading content...

Implementors

impl FromStr for Category

type Err = Error

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

impl FromStr for Severity

type Err = Error

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

impl FromStr for Informational

type Err = Error

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

impl FromStr for Collection

type Err = Error

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

impl FromStr for ResolveVersion

type Err = Error

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

impl FromStr for Checksum

type Err = Error

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

impl FromStr for FunctionPath

type Err = Error

fn from_str(path: &str) -> Result<Self, Error>

Parse a canonical, parameter-free path contained in an advisory

impl FromStr for Identifier

type Err = Error

fn from_str(identifier: &str) -> Result<Self, Error>

Parse an Identifier within a path

impl FromStr for Date

type Err = Error

fn from_str(rfc3339_date: &str) -> Result<Self, Error>

Create a Date from the given RFC 3339 date string

impl FromStr for Id

type Err = Error

fn from_str(advisory_id: &str) -> Result<Self, Error>

Create an Id from the given string

impl FromStr for Keyword

type Err = Error

fn from_str(keyword: &str) -> Result<Self, Error>

Create a new keyword

impl FromStr for Advisory

type Err = Error

fn from_str(toml_string: &str) -> Result<Self, Error>

impl FromStr for Lockfile

type Err = Error

fn from_str(toml_string: &str) -> Result<Lockfile, Error>

impl FromStr for rustsec::package::Name

type Err = Error

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

impl FromStr for SourceId

type Err = Error

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

impl FromStr for rustsec::package::Version

type Err = SemVerError

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

impl FromStr for rustsec::VersionReq

type Err = Error

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

impl FromStr for rustsec::version::Version

type Err = Error

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

Loading content...