nyx_space::cosmic

Trait 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§

1.0.0 · Source

type Err

The associated error which can be returned from parsing.

Required Methods§

1.0.0 · Source

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

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§

Source§

impl FromStr for StateParameter

§

impl FromStr for MonthName

Source§

impl FromStr for IntegratorMethod

§

impl FromStr for TimeScale

§

impl FromStr for nyx_space::time::Weekday

1.7.0 · Source§

impl FromStr for IpAddr

1.0.0 · Source§

impl FromStr for SocketAddr

Source§

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

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

impl FromStr for IpNet

Source§

impl FromStr for log::Level

Source§

impl FromStr for log::LevelFilter

Source§

impl FromStr for serde_json::value::Value

1.0.0 · Source§

impl FromStr for bool

1.20.0 · Source§

impl FromStr for char

1.0.0 · Source§

impl FromStr for f32

1.0.0 · Source§

impl FromStr for f64

1.0.0 · Source§

impl FromStr for i8

1.0.0 · Source§

impl FromStr for i16

1.0.0 · Source§

impl FromStr for i32

1.0.0 · Source§

impl FromStr for i64

1.0.0 · Source§

impl FromStr for i128

1.0.0 · Source§

impl FromStr for isize

1.0.0 · Source§

impl FromStr for u8

1.0.0 · Source§

impl FromStr for u16

1.0.0 · Source§

impl FromStr for u32

1.0.0 · Source§

impl FromStr for u64

1.0.0 · Source§

impl FromStr for u128

1.0.0 · Source§

impl FromStr for usize

§

impl FromStr for MetaAlmanac

§

type Err = MetaAlmanacError

Source§

impl FromStr for TrkConfig

§

impl FromStr for Duration

§

impl FromStr for Epoch

§

impl FromStr for Format

Source§

impl FromStr for CString

1.0.0 · Source§

impl FromStr for alloc::string::String

1.0.0 · Source§

impl FromStr for Ipv4Addr

1.0.0 · Source§

impl FromStr for Ipv6Addr

1.5.0 · Source§

impl FromStr for SocketAddrV4

1.5.0 · Source§

impl FromStr for SocketAddrV6

1.35.0 · Source§

impl FromStr for NonZero<i8>

1.35.0 · Source§

impl FromStr for NonZero<i16>

1.35.0 · Source§

impl FromStr for NonZero<i32>

1.35.0 · Source§

impl FromStr for NonZero<i64>

1.35.0 · Source§

impl FromStr for NonZero<i128>

1.35.0 · Source§

impl FromStr for NonZero<isize>

1.35.0 · Source§

impl FromStr for NonZero<u8>

1.35.0 · Source§

impl FromStr for NonZero<u16>

1.35.0 · Source§

impl FromStr for NonZero<u32>

1.35.0 · Source§

impl FromStr for NonZero<u64>

1.35.0 · Source§

impl FromStr for NonZero<u128>

1.35.0 · Source§

impl FromStr for NonZero<usize>

1.45.0 · Source§

impl FromStr for OsString

1.32.0 · Source§

impl FromStr for PathBuf

Source§

impl FromStr for chrono::datetime::DateTime<FixedOffset>

Accepts a relaxed form of RFC3339. A space or a ‘T’ are accepted 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>>()?;
Source§

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>>()?;
Source§

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>>()?;
Source§

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

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

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

impl FromStr for FixedOffset

Parsing a str into a FixedOffset uses the format %z.

Source§

impl FromStr for half::bfloat::bf16

Source§

impl FromStr for half::binary16::f16

Source§

impl FromStr for half::bfloat::bf16

Source§

impl FromStr for half::binary16::f16

Source§

impl FromStr for http::header::name::HeaderName

Source§

impl FromStr for http::header::value::HeaderValue

Source§

impl FromStr for http::method::Method

Source§

impl FromStr for http::status::StatusCode

Source§

impl FromStr for http::uri::authority::Authority

Source§

impl FromStr for http::uri::path::PathAndQuery

Source§

impl FromStr for http::uri::scheme::Scheme

Source§

impl FromStr for http::uri::Uri

Source§

impl FromStr for Ipv4Net

Source§

impl FromStr for Ipv6Net

Source§

impl FromStr for Mime

Source§

impl FromStr for BigInt

Source§

impl FromStr for BigUint

Source§

impl FromStr for serde_json::number::Number

Source§

impl FromStr for serde_yml::number::Number

Source§

impl FromStr for Url

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

§

impl FromStr for Attribute

§

type Err = ParserError

§

impl FromStr for Authority

§

type Err = InvalidUri

§

impl FromStr for BmpString

§

type Err = Error

§

impl FromStr for Compression

§

type Err = ParquetError

§

impl FromStr for ConvertedType

§

type Err = ParquetError

§

impl FromStr for DataLocale

§

type Err = DataError

§

impl FromStr for DataType

Parses str into a DataType.

This is the reverse of [DataType]’s Display impl, and maintains the invariant that DataType::try_from(&data_type.to_string()).unwrap() == data_type

§Example

use arrow_schema::DataType;

let data_type: DataType = "Int32".parse().unwrap();
assert_eq!(data_type, DataType::Int32);
§

type Err = ArrowError

§

impl FromStr for DateTime

§

type Err = Error

§

impl FromStr for EnabledStatistics

§

type Err = String

§

impl FromStr for Encoding

§

type Err = ParquetError

§

impl FromStr for HeaderName

§

type Err = InvalidHeaderName

§

impl FromStr for HeaderValue

§

type Err = InvalidHeaderValue

§

impl FromStr for IntervalUnit

Logic for parsing interval unit strings

See https://github.com/postgres/postgres/blob/2caa85f4aae689e6f6721d7363b4c66a2a6417d6/src/backend/utils/adt/datetime.c#L189 for a list of unit names supported by PostgreSQL which we try to match here.

§

type Err = ArrowError

§

impl FromStr for Key

§

type Err = ParserError

§

impl FromStr for Key

§

type Err = ParserError

§

impl FromStr for Language

§

type Err = ParserError

§

impl FromStr for LanguageIdentifier

§

type Err = ParserError

§

impl FromStr for Level

§

type Err = ParseLevelError

§

impl FromStr for LevelFilter

§

type Err = ParseLevelFilterError

§

impl FromStr for Locale

§

type Err = ParserError

§

impl FromStr for LogicalType

§

type Err = ParquetError

§

impl FromStr for Method

§

type Err = InvalidMethod

§

impl FromStr for Month

§

type Err = InvalidVariant

§

impl FromStr for Name

§

type Err = InvalidNameError

§

impl FromStr for Name

§

type Err = InvalidNameError

§

impl FromStr for Name

§

type Err = InvalidNameError

§

impl FromStr for Parameter

§

type Err = Whatever

§

impl FromStr for PathAndQuery

§

type Err = InvalidUri

§

impl FromStr for Regex

§

type Err = Error

§

impl FromStr for Regex

§

type Err = Error

§

impl FromStr for Region

§

type Err = ParserError

§

impl FromStr for Repetition

§

type Err = ParquetError

§

impl FromStr for Scheme

§

type Err = InvalidUri

§

impl FromStr for Script

§

type Err = ParserError

§

impl FromStr for StatusCode

§

type Err = InvalidStatusCode

§

impl FromStr for Subtag

§

type Err = ParserError

§

impl FromStr for Subtag

§

type Err = ParserError

§

impl FromStr for TagMode

§

type Err = Error

§

impl FromStr for Type

§

type Err = ParquetError

§

impl FromStr for Tz

§

type Err = ArrowError

§

impl FromStr for Uri

§

type Err = InvalidUri

§

impl FromStr for Value

§

type Err = ParserError

§

impl FromStr for Value

§

type Err = ParserError

§

impl FromStr for Variant

§

type Err = ParserError

§

impl FromStr for Weekday

§

type Err = InvalidVariant

§

impl FromStr for WriterVersion

§

type Err = String

§

impl FromStr for i256

§

type Err = ParseI256Error

Source§

impl<T> FromStr for Complex<T>
where T: FromStr + Num + Clone,

Source§

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

§

impl<T> FromStr for NotNan<T>
where T: Float + FromStr,

§

type Err = ParseNotNanError<<T as FromStr>::Err>

§

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

§

type Err = NumberPrefixParseError

§

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

§

type Err = <T as FromStr>::Err

§

impl<const MIN: i8, const MAX: i8> FromStr for RangedI8<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: i16, const MAX: i16> FromStr for RangedI16<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: i32, const MAX: i32> FromStr for RangedI32<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: i64, const MAX: i64> FromStr for RangedI64<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: i128, const MAX: i128> FromStr for RangedI128<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: isize, const MAX: isize> FromStr for RangedIsize<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u8, const MAX: u8> FromStr for RangedU8<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u16, const MAX: u16> FromStr for RangedU16<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u32, const MAX: u32> FromStr for RangedU32<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u64, const MAX: u64> FromStr for RangedU64<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: u128, const MAX: u128> FromStr for RangedU128<MIN, MAX>

§

type Err = ParseIntError

§

impl<const MIN: usize, const MAX: usize> FromStr for RangedUsize<MIN, MAX>

§

type Err = ParseIntError

§

impl<const N: usize> FromStr for String<N>

§

type Err = ()

§

impl<const N: usize> FromStr for TinyAsciiStr<N>

§

type Err = TinyStrError