(index<- )        ./libstd/from_str.rs

    git branch:    * master           5200215 auto merge of #14035 : alexcrichton/rust/experimental, r=huonw
    modified:    Fri May  9 13:02:28 2014
  1  // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
  2  // file at the top-level directory of this distribution and at
  3  // http://rust-lang.org/COPYRIGHT.
  4  //
  5  // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
  6  // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
  7  // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
  8  // option. This file may not be copied, modified, or distributed
  9  // except according to those terms.
 10  
 11  //! The `FromStr` trait for types that can be created from strings
 12  
 13  use option::{Option, Some, None};
 14  
 15  /// A trait to abstract the idea of creating a new instance of a type from a
 16  /// string.
 17  pub trait FromStr {
 18      /// Parses a string `s` to return an optional value of this type. If the
 19      /// string is ill-formatted, the None is returned.
 20      fn from_str(s: &str) -> Option<Self>;
 21  }
 22  
 23  /// A utility function that just calls FromStr::from_str
 24  pub fn from_str<A: FromStr>(s: &str) -> Option<A> {
 25      FromStr::from_str(s)
 26  }
 27  
 28  impl FromStr for bool {
 29      /// Parse a `bool` from a string.
 30      ///
 31      /// Yields an `Option<bool>`, because `s` may or may not actually be parseable.
 32      ///
 33      /// # Examples
 34      ///
 35      /// ```rust
 36      /// assert_eq!(from_str::<bool>("true"), Some(true));
 37      /// assert_eq!(from_str::<bool>("false"), Some(false));
 38      /// assert_eq!(from_str::<bool>("not even a boolean"), None);
 39      /// ```
 40      #[inline]
 41      fn from_str(s&str) -> Option<bool> {
 42          match s {
 43              "true"  => Some(true),
 44              "false" => Some(false),
 45              _       => None,
 46          }
 47      }
 48  }
 49  
 50  #[cfg(test)]
 51  mod test {
 52      use prelude::*;
 53  
 54      #[test]
 55      fn test_bool_from_str() {
 56          assert_eq!(from_str::<bool>("true"), Some(true));
 57          assert_eq!(from_str::<bool>("false"), Some(false));
 58          assert_eq!(from_str::<bool>("not even a boolean"), None);
 59      }
 60  }


libstd/from_str.rs:23:57-23:57 -fn- definition:
/// A utility function that just calls FromStr::from_str
pub fn from_str<A: FromStr>(s: &str) -> Option<A> {
    FromStr::from_str(s)
references:- 3
libstd/rt/env.rs:
27:         match os::getenv("RUST_MIN_STACK") {
28:             Some(s) => match from_str(s) {
29:                 Some(i) => MIN_STACK = i,
libstd/rt/backtrace.rs:
110:             }
111:             let i: uint = from_str(s.slice_to(s.len() - rest.len())).unwrap();
112:             s = rest.slice_from(i);
libstd/rt/env.rs:
34:         match os::getenv("RUST_MAX_CACHED_STACKS") {
35:             Some(max) => MAX_CACHED_STACKS = from_str(max).expect("expected positive integer in \
36:                                                                    RUST_MAX_CACHED_STACKS"),


libstd/from_str.rs:16:12-16:12 -trait- definition:
/// string.
pub trait FromStr {
    /// Parses a string `s` to return an optional value of this type. If the
references:- 20
19:     /// string is ill-formatted, the None is returned.
20:     fn from_str(s: &str) -> Option<Self>;
21: }
--
23: /// A utility function that just calls FromStr::from_str
24: pub fn from_str<A: FromStr>(s: &str) -> Option<A> {
25:     FromStr::from_str(s)
libstd/io/net/ip.rs:
332: impl FromStr for IpAddr {
333:     fn from_str(s: &str) -> Option<IpAddr> {
--
338: impl FromStr for SocketAddr {
339:     fn from_str(s: &str) -> Option<SocketAddr> {
libstd/path/posix.rs:
76: impl FromStr for Path {
77:     fn from_str(s: &str) -> Option<Path> {
libstd/path/windows.rs:
100: impl FromStr for Path {
101:     fn from_str(s: &str) -> Option<Path> {
libstd/num/int_macros.rs:
34: impl FromStr for $T {
35:     #[inline]
libstd/num/uint_macros.rs:
35: impl FromStr for $T {
36:     #[inline]
libstd/num/f32.rs:
655: impl FromStr for f32 {
656:     /// Convert a string in base 10 to a float.
libstd/num/f64.rs:
664: impl FromStr for f64 {
665:     /// Convert a string in base 10 to a float.
libstd/str.rs:
117: impl FromStr for ~str {
118:     #[inline]
libstd/from_str.rs:
28: impl FromStr for bool {
29:     /// Parse a `bool` from a string.