Trait switchboard_utils::FromStr
1.0.0 · source · pub trait FromStr: Sized {
type Err;
// Required method
fn from_str(s: &str) -> Result<Self, Self::Err>;
}
Expand description
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;
#[derive(Debug, PartialEq)]
struct Point {
x: i32,
y: i32
}
#[derive(Debug, PartialEq, Eq)]
struct ParsePointError;
impl FromStr for Point {
type Err = ParsePointError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let (x, y) = s
.strip_prefix('(')
.and_then(|s| s.strip_suffix(')'))
.and_then(|s| s.split_once(','))
.ok_or(ParsePointError)?;
let x_fromstr = x.parse::<i32>().map_err(|_| ParsePointError)?;
let y_fromstr = y.parse::<i32>().map_err(|_| ParsePointError)?;
Ok(Point { x: x_fromstr, y: y_fromstr })
}
}
let expected = Ok(Point { x: 1, y: 2 });
// Explicit call
assert_eq!(Point::from_str("(1,2)"), expected);
// Implicit calls, through parse
assert_eq!("(1,2)".parse(), expected);
assert_eq!("(1,2)".parse::<Point>(), expected);
// Invalid input string
assert!(Point::from_str("(1 2)").is_err());
Required Associated Types§
Required Methods§
sourcefn from_str(s: &str) -> Result<Self, Self::Err>
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 the 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);
Object Safety§
Implementors§
source§impl FromStr for SocketAddr
impl FromStr for SocketAddr
type Err = AddrParseError
source§impl FromStr for chrono::month::Month
impl FromStr for chrono::month::Month
Parsing a str
into a Month
uses the format %B
.
Example
use chrono::Month;
assert_eq!("January".parse::<Month>(), Ok(Month::January));
assert!("any day".parse::<Month>().is_err());
The parsing is case-insensitive.
assert_eq!("fEbruARy".parse::<Month>(), Ok(Month::February));
Only the shortest form (e.g. jan
) and the longest form (e.g. january
) is accepted.
assert!("septem".parse::<Month>().is_err());
assert!("Augustin".parse::<Month>().is_err());
type Err = ParseMonthError
source§impl FromStr for chrono::weekday::Weekday
impl FromStr for chrono::weekday::Weekday
Parsing a str
into a Weekday
uses the format %A
.
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
source§impl FromStr for log::LevelFilter
impl FromStr for log::LevelFilter
type Err = ParseLevelError
1.5.0 · source§impl FromStr for SocketAddrV4
impl FromStr for SocketAddrV4
type Err = AddrParseError
1.5.0 · source§impl FromStr for SocketAddrV6
impl FromStr for SocketAddrV6
type Err = AddrParseError
1.35.0 · source§impl FromStr for NonZeroI16
impl FromStr for NonZeroI16
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroI32
impl FromStr for NonZeroI32
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroI64
impl FromStr for NonZeroI64
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroI128
impl FromStr for NonZeroI128
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroIsize
impl FromStr for NonZeroIsize
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroU16
impl FromStr for NonZeroU16
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroU32
impl FromStr for NonZeroU32
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroU64
impl FromStr for NonZeroU64
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroU128
impl FromStr for NonZeroU128
type Err = ParseIntError
1.35.0 · source§impl FromStr for NonZeroUsize
impl FromStr for NonZeroUsize
type Err = ParseIntError
1.54.0 · source§impl FromStr for proc_macro::Literal
impl FromStr for proc_macro::Literal
Parse a single literal from its stringified representation.
In order to parse successfully, the input string must not contain anything but the literal token. Specifically, it must not contain whitespace or comments in addition to the literal.
The resulting literal token will have a Span::call_site()
span.
NOTE: some errors may cause panics instead of returning LexError
. We
reserve the right to change these errors into LexError
s later.
1.15.0 · source§impl FromStr for proc_macro::TokenStream
impl FromStr for proc_macro::TokenStream
Attempts to break the string into tokens and parse those tokens into a token stream.
May fail for a number of reasons, for example, if the string contains unbalanced delimiters
or characters not existing in the language.
All tokens in the parsed stream get Span::call_site()
spans.
NOTE: some errors may cause panics instead of returning LexError
. We reserve the right to
change these errors into LexError
s later.
source§impl FromStr for chrono::datetime::DateTime<FixedOffset>
impl FromStr for chrono::datetime::DateTime<FixedOffset>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are acepted as the separator between the date and time parts. Additional spaces are allowed between each component.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<FixedOffset>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<FixedOffset>>()?;
"2012- 12-12T12: 12:12Z".parse::<DateTime<FixedOffset>>()?;
type Err = ParseError
source§impl FromStr for chrono::datetime::DateTime<Local>
impl FromStr for chrono::datetime::DateTime<Local>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are accepted as the separator between the date and time parts.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12+0000".parse::<DateTime<Local>>()?;
"2012-12-12 12:12:12+00:00".parse::<DateTime<Local>>()?;
type Err = ParseError
source§impl FromStr for chrono::datetime::DateTime<Utc>
impl FromStr for chrono::datetime::DateTime<Utc>
Accepts a relaxed form of RFC3339. A space or a ‘T’ are accepted as the separator between the date and time parts.
All of these examples are equivalent:
"2012-12-12T12:12:12Z".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12Z".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12+0000".parse::<DateTime<Utc>>()?;
"2012-12-12 12:12:12+00:00".parse::<DateTime<Utc>>()?;
type Err = ParseError
source§impl FromStr for NaiveDate
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_opt(2015, 9, 18).unwrap();
assert_eq!("2015-09-18".parse::<NaiveDate>(), Ok(d));
let d = NaiveDate::from_ymd_opt(12345, 6, 7).unwrap();
assert_eq!("+12345-6-7".parse::<NaiveDate>(), Ok(d));
assert!("foo".parse::<NaiveDate>().is_err());
type Err = ParseError
source§impl FromStr for NaiveDateTime
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_opt(2015, 9, 18).unwrap().and_hms_opt(23, 56, 4).unwrap();
assert_eq!("2015-09-18T23:56:04".parse::<NaiveDateTime>(), Ok(dt));
let dt = NaiveDate::from_ymd_opt(12345, 6, 7).unwrap().and_hms_milli_opt(7, 59, 59, 1_500).unwrap(); // leap second
assert_eq!("+12345-6-7T7:59:60.5".parse::<NaiveDateTime>(), Ok(dt));
assert!("foo".parse::<NaiveDateTime>().is_err());
type Err = ParseError
source§impl FromStr for NaiveTime
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_opt(23, 56, 4).unwrap();
assert_eq!("23:56:04".parse::<NaiveTime>(), Ok(t));
let t = NaiveTime::from_hms_nano_opt(23, 56, 4, 12_345_678).unwrap();
assert_eq!("23:56:4.012345678".parse::<NaiveTime>(), Ok(t));
let t = NaiveTime::from_hms_nano_opt(23, 59, 59, 1_234_567_890).unwrap(); // leap second
assert_eq!("23:59:60.23456789".parse::<NaiveTime>(), Ok(t));
// Seconds are optional
let t = NaiveTime::from_hms_opt(23, 56, 0).unwrap();
assert_eq!("23:56".parse::<NaiveTime>(), Ok(t));
assert!("foo".parse::<NaiveTime>().is_err());
type Err = ParseError
source§impl FromStr for FixedOffset
impl FromStr for FixedOffset
Parsing a str
into a FixedOffset
uses the format %z
.
type Err = ParseError
source§impl FromStr for HeaderName
impl FromStr for HeaderName
type Err = InvalidHeaderName
source§impl FromStr for HeaderValue
impl FromStr for HeaderValue
type Err = InvalidHeaderValue
source§impl FromStr for StatusCode
impl FromStr for StatusCode
type Err = InvalidStatusCode
source§impl FromStr for PathAndQuery
impl FromStr for PathAndQuery
type Err = InvalidUri
source§impl FromStr for proc_macro2::TokenStream
impl FromStr for proc_macro2::TokenStream
Attempts to break the string into tokens and parse those tokens into a token stream.
May fail for a number of reasons, for example, if the string contains unbalanced delimiters or characters not existing in the language.
NOTE: Some errors may cause panics instead of returning LexError
. We
reserve the right to change these errors into LexError
s later.
source§impl FromStr for Url
impl FromStr for Url
Parse a string as an URL, without a base URL or encoding override.
type Err = ParseError
§impl FromStr for InternalString
impl FromStr for InternalString
type Err = Infallible
§impl FromStr for Provider
impl FromStr for Provider
type Err = ParseError
§impl FromStr for Utf8PathBuf
impl FromStr for Utf8PathBuf
type Err = Infallible
§impl<C> FromStr for Signature<C>where
C: PrimeCurve + CurveArithmetic,
<<C as Curve>::FieldBytesSize as Add>::Output: ArrayLength<u8>,
impl<C> FromStr for Signature<C>where C: PrimeCurve + CurveArithmetic, <<C as Curve>::FieldBytesSize as Add>::Output: ArrayLength<u8>,
§impl<Size> FromStr for EncodedPoint<Size>where
Size: ModulusSize,
impl<Size> FromStr for EncodedPoint<Size>where Size: ModulusSize,
Decode a SEC1-encoded point from hexadecimal.
Upper and lower case hexadecimal are both accepted, however mixed case is rejected.