Struct clap_lex::RawOsString

source · [−]

pub struct RawOsString(_);

Expand description

A container for the byte strings converted by OsStringBytes.

For more information, see RawOsStr.

Implementations

source

impl RawOsString

source

pub fn new(string: OsString) -> RawOsString

Converts a platform-native string into a representation that can be more easily manipulated.

For more information, see RawOsStr::new.

Examples

use std::env;

use os_str_bytes::RawOsString;

let os_string = env::current_exe()?.into_os_string();
println!("{:?}", RawOsString::new(os_string));

source

pub fn from_string(string: String) -> RawOsString

Wraps a string, without copying or encoding conversion.

This method is much more efficient than RawOsString::new, since the encoding used by this crate is compatible with UTF-8.

Examples

use os_str_bytes::RawOsString;

let string = "foobar".to_owned();
let raw = RawOsString::from_string(string.clone());
assert_eq!(string, raw);

source

pub fn into_os_string(self) -> OsString

Converts this representation back to a platform-native string.

Examples

use std::env;

use os_str_bytes::RawOsString;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsString::new(os_string.clone());
assert_eq!(os_string, raw.into_os_string());

source

pub fn into_raw_vec(self) -> Vec<u8, Global>

Returns the byte string stored by this container.

The result will match what would be returned by OsStringBytes::into_raw_vec for the same string.

Examples

use std::env;

use os_str_bytes::OsStringBytes;
use os_str_bytes::RawOsString;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsString::new(os_string.clone());
assert_eq!(os_string.into_raw_vec(), raw.into_raw_vec());

source

pub fn into_string(self) -> Result<String, RawOsString>

Equivalent to OsString::into_string.

Examples

use os_str_bytes::RawOsString;

let string = "foobar".to_owned();
let raw = RawOsString::from_string(string.clone());
assert_eq!(Ok(string), raw.into_string());

Methods from Deref<Target = RawOsStr>

source

pub fn as_raw_bytes(&self) -> &[u8]ⓘNotable traits for &[u8]`impl<'_> Read for &[u8]impl<'_> Write for &mut [u8]`

Returns the byte string stored by this container.

The result will match what would be returned by OsStrBytes::to_raw_bytes for the same string.

Examples

use std::env;

use os_str_bytes::OsStrBytes;
use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
assert_eq!(os_string.to_raw_bytes(), raw.as_raw_bytes());

source

pub fn contains(&self, pat: P) -> bool where
P: Pattern,

Equivalent to str::contains.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert!(raw.contains("oo"));
assert!(!raw.contains("of"));

source

pub fn ends_with(&self, pat: P) -> bool where
P: Pattern,

Equivalent to str::ends_with.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert!(raw.ends_with("bar"));
assert!(!raw.ends_with("foo"));

source

pub fn ends_with_os(&self, pat: &RawOsStr) -> bool

Equivalent to str::ends_with but accepts this type for the pattern.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert!(raw.ends_with_os(RawOsStr::from_str("bar")));
assert!(!raw.ends_with_os(RawOsStr::from_str("foo")));

source

pub fn find(&self, pat: P) -> Option<usize> where
P: Pattern,

Equivalent to str::find.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert_eq!(Some(1), raw.find("o"));
assert_eq!(None, raw.find("of"));

source

pub fn is_empty(&self) -> bool

Equivalent to str::is_empty.

Examples

use os_str_bytes::RawOsStr;

assert!(RawOsStr::from_str("").is_empty());
assert!(!RawOsStr::from_str("foobar").is_empty());

source

pub fn raw_len(&self) -> usize

Returns the length of the byte string stored by this container.

Only the following assumptions can be made about the result:

The length of any Unicode character is the length of its UTF-8 representation (i.e., char::len_utf8).
Splitting a string at a UTF-8 boundary will return two strings with lengths that sum to the length of the original string.

This method may return a different result than would OsStr::len when called on same string, since OsStr uses an unspecified encoding.

Examples

use os_str_bytes::RawOsStr;

assert_eq!(6, RawOsStr::from_str("foobar").raw_len());
assert_eq!(0, RawOsStr::from_str("").raw_len());

source

pub fn rfind(&self, pat: P) -> Option<usize> where
P: Pattern,

Equivalent to str::rfind.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert_eq!(Some(2), raw.rfind("o"));
assert_eq!(None, raw.rfind("of"));

source

pub fn rsplit_once(&self, pat: P) -> Option<(&RawOsStr, &RawOsStr)> where
P: Pattern,

Equivalent to str::rsplit_once.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert_eq!(
    Some((RawOsStr::from_str("fo"), RawOsStr::from_str("bar"))),
    raw.rsplit_once("o"),
);
assert_eq!(None, raw.rsplit_once("of"));

source

pub fn split(&self, pat: P) -> Split<'_, P> where
P: Pattern,

Equivalent to str::split, but empty patterns are not accepted.

Panics

Panics if the pattern is a byte outside of the ASCII range or empty.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert_eq!(["f", "", "bar"], *raw.split("o").collect::<Vec<_>>());

source

pub fn split_at(&self, mid: usize) -> (&RawOsStr, &RawOsStr)

Equivalent to str::split_at.

Panics

Panics if the index is not a valid boundary.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert_eq!(
    ((RawOsStr::from_str("fo"), RawOsStr::from_str("obar"))),
    raw.split_at(2),
);

source

pub fn split_once(&self, pat: P) -> Option<(&RawOsStr, &RawOsStr)> where
P: Pattern,

Equivalent to str::split_once.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert_eq!(
    Some((RawOsStr::from_str("f"), RawOsStr::from_str("obar"))),
    raw.split_once("o"),
);
assert_eq!(None, raw.split_once("of"));

source

pub fn starts_with(&self, pat: P) -> bool where
P: Pattern,

Equivalent to str::starts_with.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert!(raw.starts_with("foo"));
assert!(!raw.starts_with("bar"));

source

pub fn starts_with_os(&self, pat: &RawOsStr) -> bool

Equivalent to str::starts_with but accepts this type for the pattern.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("foobar");
assert!(raw.starts_with_os(RawOsStr::from_str("foo")));
assert!(!raw.starts_with_os(RawOsStr::from_str("bar")));

source

pub fn strip_prefix(&self, pat: P) -> Option<&RawOsStr> where
P: Pattern,

Equivalent to str::strip_prefix.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("111foo1bar111");
assert_eq!(
    Some(RawOsStr::from_str("11foo1bar111")),
    raw.strip_prefix("1"),
);
assert_eq!(None, raw.strip_prefix("o"));

source

pub fn strip_suffix(&self, pat: P) -> Option<&RawOsStr> where
P: Pattern,

Equivalent to str::strip_suffix.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("111foo1bar111");
assert_eq!(
    Some(RawOsStr::from_str("111foo1bar11")),
    raw.strip_suffix("1"),
);
assert_eq!(None, raw.strip_suffix("o"));

source

pub fn to_os_str(&self) -> Cow<'_, OsStr>

Converts this representation back to a platform-native string.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
assert_eq!(os_string, raw.to_os_str());

source

pub fn to_str(&self) -> Option<&str>

Equivalent to OsStr::to_str.

Examples

use os_str_bytes::RawOsStr;

let string = "foobar";
let raw = RawOsStr::from_str(string);
assert_eq!(Some(string), raw.to_str());

source

pub fn to_str_lossy(&self) -> Cow<'_, str>

Converts this string to the best UTF-8 representation possible.

Invalid sequences will be replaced with char::REPLACEMENT_CHARACTER.

This method may return a different result than would OsStr::to_string_lossy when called on same string, since OsStr uses an unspecified encoding.

Examples

use std::env;

use os_str_bytes::RawOsStr;

let os_string = env::current_exe()?.into_os_string();
let raw = RawOsStr::new(&os_string);
println!("{}", raw.to_str_lossy());

source

pub fn trim_end_matches(&self, pat: P) -> &RawOsStr where
P: Pattern,

Equivalent to str::trim_end_matches.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("111foo1bar111");
assert_eq!("111foo1bar", raw.trim_end_matches("1"));
assert_eq!("111foo1bar111", raw.trim_end_matches("o"));

source

pub fn trim_start_matches(&self, pat: P) -> &RawOsStr where
P: Pattern,

Equivalent to str::trim_start_matches.

Panics

Panics if the pattern is a byte outside of the ASCII range.

Examples

use os_str_bytes::RawOsStr;

let raw = RawOsStr::from_str("111foo1bar111");
assert_eq!("foo1bar111", raw.trim_start_matches("1"));
assert_eq!("111foo1bar111", raw.trim_start_matches("o"));