Struct java_string :: JavaStr Copy item path

impl JavaStr

pub fn from_modified_utf8(bytes: &[u8]) -> Result<Cow<'_, JavaStr>, Utf8Error>

Converts from Java’s modified UTF-8 format to a Cow<JavaStr>.


let result = JavaStr::from_modified_utf8("Hello World!".as_bytes()).unwrap();
assert!(matches!(result, Cow::Borrowed(_)));
assert_eq!(JavaStr::from_str("Hello World!"), result);

let result = JavaStr::from_modified_utf8(&[
    0x61, 0x62, 0x63, 0xc0, 0x80, 0xe2, 0x84, 0x9d, 0xed, 0xa0, 0xbd, 0xed, 0xb2, 0xa3, 0xed,
    0xa0, 0x80,
])
.unwrap();
assert!(matches!(result, Cow::Owned(_)));
let mut expected = JavaString::from("abc\0ℝ💣");
expected.push_java(JavaCodePoint::from_u32(0xd800).unwrap());
assert_eq!(expected, result);

let result = JavaStr::from_modified_utf8(&[0xed]);
assert!(result.is_err());

pub fn to_modified_utf8(&self) -> Cow<'_, [u8]>

Converts to Java’s modified UTF-8 format.


let result = JavaStr::from_str("Hello World!").to_modified_utf8();
assert!(matches!(result, Cow::Borrowed(_)));
assert_eq!(result, &b"Hello World!"[..]);

let mut str = JavaString::from("abc\0ℝ💣");
str.push_java(JavaCodePoint::from_u32(0xd800).unwrap());
let result = str.to_modified_utf8();
let expected = [
    0x61, 0x62, 0x63, 0xc0, 0x80, 0xe2, 0x84, 0x9d, 0xed, 0xa0, 0xbd, 0xed, 0xb2, 0xa3, 0xed,
    0xa0, 0x80,
];
assert!(matches!(result, Cow::Owned(_)));
assert_eq!(result, &expected[..]);

impl JavaStr

pub const fn from_full_utf8(v: &[u8]) -> Result<&JavaStr, Utf8Error>

Converts v to a &JavaStr if it is fully-valid UTF-8, i.e. UTF-8 without surrogate code points. See std::str::from_utf8.

pub fn from_full_utf8_mut(v: &mut [u8]) -> Result<&mut JavaStr, Utf8Error>

Converts v to a &mut JavaStr if it is fully-valid UTF-8, i.e. UTF-8 without surrogate code points. See std::str::from_utf8_mut.

pub fn from_semi_utf8(v: &[u8]) -> Result<&JavaStr, Utf8Error>

Converts v to a &JavaStr if it is semi-valid UTF-8, i.e. UTF-8 with surrogate code points.

pub fn from_semi_utf8_mut(v: &mut [u8]) -> Result<&mut JavaStr, Utf8Error>

Converts v to a &mut JavaStr if it is semi-valid UTF-8, i.e. UTF-8 with surrogate code points.

pub const unsafe fn from_semi_utf8_unchecked(v: &[u8]) -> &JavaStr

§Safety

The parameter must be in semi-valid UTF-8 format, that is, UTF-8 plus surrogate code points.

pub unsafe fn from_semi_utf8_unchecked_mut(v: &mut [u8]) -> &mut JavaStr

§Safety

The parameter must be in semi-valid UTF-8 format, that is, UTF-8 plus surrogate code points.

pub unsafe fn from_boxed_semi_utf8_unchecked(v: Box<[u8]>) -> Box<JavaStr>

§Safety

The parameter must be in semi-valid UTF-8 format, that is, UTF-8 plus surrogate code points.

pub const fn as_bytes(&self) -> &[u8] ⓘ

See str::as_bytes.

pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8] ⓘ

See str::as_bytes_mut.

§Safety

The returned slice must not have invalid UTF-8 written to it, besides surrogate pairs.

pub fn as_mut_ptr(&mut self) -> *mut u8

See str::as_mut_ptr.

pub const fn as_ptr(&self) -> *const u8

See str::as_ptr.

pub const fn as_str(&self) -> Result<&str, Utf8Error>

Tries to convert this &JavaStr to a &str, returning an error if it is not fully valid UTF-8, i.e. has no surrogate code points.

pub const unsafe fn as_str_unchecked(&self) -> &str

§Safety

This string must be fully valid UTF-8, i.e. have no surrogate code points.

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

Converts this &JavaStr to a Cow<str>, replacing surrogate code points with the replacement character �.

let s = JavaStr::from_str("Hello 🦀 World!");
let result = s.as_str_lossy();
assert!(matches!(result, Cow::Borrowed(_)));
assert_eq!(result, "Hello 🦀 World!");

let s = JavaString::from("Hello ")
    + JavaString::from(JavaCodePoint::from_u32(0xd800).unwrap()).as_java_str()
    + JavaStr::from_str(" World!");
let result = s.as_str_lossy();
assert!(matches!(result, Cow::Owned(_)));
assert_eq!(result, "Hello � World!");

pub fn bytes(&self) -> Bytes<'_> ⓘ

See str::bytes.

pub fn char_indices(&self) -> CharIndices<'_> ⓘ

See str::char_indices.

pub fn chars(&self) -> Chars<'_> ⓘ

See str::chars.

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

See str::contains.

let bananas = JavaStr::from_str("bananas");

assert!(bananas.contains("nana"));
assert!(!bananas.contains("apples"));

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

See str::ends_with.

let bananas = JavaStr::from_str("bananas");

assert!(bananas.ends_with("anas"));
assert!(!bananas.ends_with("nana"));

pub fn eq_ignore_ascii_case(&self, other: &str) -> bool

See str::eq_ignore_ascii_case.

pub fn eq_java_ignore_ascii_case(&self, other: &JavaStr) -> bool

See str::eq_ignore_ascii_case.

pub fn escape_debug(&self) -> EscapeDebug<'_> ⓘ

See str::escape_debug.

assert_eq!(
    JavaStr::from_str("❤\n!").escape_debug().to_string(),
    "❤\\n!"
);

pub fn escape_default(&self) -> EscapeDefault<'_> ⓘ

See str::escape_default.

assert_eq!(
    JavaStr::from_str("❤\n!").escape_default().to_string(),
    "\\u{2764}\\n!"
);

pub fn escape_unicode(&self) -> EscapeUnicode<'_> ⓘ

See str::escape_unicode.

assert_eq!(
    JavaStr::from_str("❤\n!").escape_unicode().to_string(),
    "\\u{2764}\\u{a}\\u{21}"
);

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

See str::find.

let s = "Löwe 老虎 Léopard Gepardi";

assert_eq!(s.find('L'), Some(0));
assert_eq!(s.find('é'), Some(14));
assert_eq!(s.find("par"), Some(17));

let x: &[_] = &['1', '2'];
assert_eq!(s.find(x), None);

pub fn get(&self, i: I) -> Option<&JavaStr>
where I: JavaStrSliceIndex,

See str::get.

let v = JavaString::from("🗻∈🌏");

assert_eq!(Some(JavaStr::from_str("🗻")), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());

pub fn get_mut(&mut self, i: I) -> Option<&mut JavaStr>
where I: JavaStrSliceIndex,

See str::get_mut.

pub unsafe fn get_unchecked(&self, i: I) -> &JavaStr
where I: JavaStrSliceIndex,

See str::get_unchecked.

§Safety

The starting index must not exceed the ending index
Indexes must be within bounds of the original slice
Indexes must lie on UTF-8 sequence boundaries

pub unsafe fn get_unchecked_mut(&mut self, i: I) -> &mut JavaStr
where I: JavaStrSliceIndex,

See str::get_unchecked_mut.

§Safety

The starting index must not exceed the ending index
Indexes must be within bounds of the original slice
Indexes must lie on UTF-8 sequence boundaries

pub fn into_boxed_bytes(self: Box<JavaStr>) -> Box<[u8]>

See str::into_boxed_bytes.

pub fn into_string(self: Box<JavaStr>) -> JavaString

See str::into_string.

pub fn is_ascii(&self) -> bool

See str::is_ascii.

pub fn is_char_boundary(&self, index: usize) -> bool

See str::is_char_boundary.

pub fn is_empty(&self) -> bool

See str::is_empty.

pub fn len(&self) -> usize

See str::len.

pub fn lines(&self) -> Lines<'_> ⓘ

See str::lines.

pub fn make_ascii_lowercase(&mut self)

See str::make_ascii_lowercase.

pub fn make_ascii_uppercase(&mut self)

See str::make_ascii_uppercase.

pub fn match_indices(&self, pat: P) -> MatchIndices<'_, P> ⓘ
where P: JavaStrPattern,

See str::match_indices.

let v: Vec<_> = JavaStr::from_str("abcXXXabcYYYabc")
    .match_indices("abc")
    .collect();
assert_eq!(
    v,
    [
        (0, JavaStr::from_str("abc")),
        (6, JavaStr::from_str("abc")),
        (12, JavaStr::from_str("abc"))
    ]
);

let v: Vec<_> = JavaStr::from_str("1abcabc2").match_indices("abc").collect();
assert_eq!(
    v,
    [(1, JavaStr::from_str("abc")), (4, JavaStr::from_str("abc"))]
);

let v: Vec<_> = JavaStr::from_str("ababa").match_indices("aba").collect();
assert_eq!(v, [(0, JavaStr::from_str("aba"))]); // only the first `aba`

pub fn matches(&self, pat: P) -> Matches<'_, P> ⓘ
where P: JavaStrPattern,

See str::matches.

let v: Vec<&JavaStr> = JavaStr::from_str("abcXXXabcYYYabc")
    .matches("abc")
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("abc"),
        JavaStr::from_str("abc"),
        JavaStr::from_str("abc")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("1abc2abc3")
    .matches(JavaCodePoint::is_numeric)
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("1"),
        JavaStr::from_str("2"),
        JavaStr::from_str("3")
    ]
);

pub fn parse<F>(&self) -> Result<F, ParseError<<F as FromStr>::Err>>
where F: FromStr,

See str::parse.

pub fn repeat(&self, n: usize) -> JavaString

See str::repeat.

pub fn replace(&self, from: P, to: &str) -> JavaString
where P: JavaStrPattern,

See str::replace.

let s = JavaStr::from_str("this is old");

assert_eq!("this is new", s.replace("old", "new"));
assert_eq!("than an old", s.replace("is", "an"));

pub fn replace_java(&self, from: P, to: &JavaStr) -> JavaString
where P: JavaStrPattern,

See str::replace.

pub fn replacen(&self, from: P, to: &str, count: usize) -> JavaString
where P: JavaStrPattern,

See str::replacen.

let s = JavaStr::from_str("foo foo 123 foo");
assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));
assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));
assert_eq!(
    "foo foo new23 foo",
    s.replacen(JavaCodePoint::is_numeric, "new", 1)
);

pub fn replacen_java( &self, from: P, to: &JavaStr, count: usize, ) -> JavaString
where P: JavaStrPattern,

See str::replacen.

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

See str::rfind.

let s = JavaStr::from_str("Löwe 老虎 Léopard Gepardi");

assert_eq!(s.rfind('L'), Some(13));
assert_eq!(s.rfind('é'), Some(14));
assert_eq!(s.rfind("par"), Some(24));

let x: &[_] = &['1', '2'];
assert_eq!(s.rfind(x), None);

pub fn rmatch_indices(&self, pat: P) -> RMatchIndices<'_, P> ⓘ
where P: JavaStrPattern,

See str::rmatch_indices.

let v: Vec<_> = JavaStr::from_str("abcXXXabcYYYabc")
    .rmatch_indices("abc")
    .collect();
assert_eq!(
    v,
    [
        (12, JavaStr::from_str("abc")),
        (6, JavaStr::from_str("abc")),
        (0, JavaStr::from_str("abc"))
    ]
);

let v: Vec<_> = JavaStr::from_str("1abcabc2")
    .rmatch_indices("abc")
    .collect();
assert_eq!(
    v,
    [(4, JavaStr::from_str("abc")), (1, JavaStr::from_str("abc"))]
);

let v: Vec<_> = JavaStr::from_str("ababa").rmatch_indices("aba").collect();
assert_eq!(v, [(2, JavaStr::from_str("aba"))]); // only the last `aba`

pub fn rmatches(&self, pat: P) -> RMatches<'_, P> ⓘ
where P: JavaStrPattern,

See str::rmatches.

let v: Vec<&JavaStr> = JavaStr::from_str("abcXXXabcYYYabc")
    .rmatches("abc")
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("abc"),
        JavaStr::from_str("abc"),
        JavaStr::from_str("abc")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("1abc2abc3")
    .rmatches(JavaCodePoint::is_numeric)
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("3"),
        JavaStr::from_str("2"),
        JavaStr::from_str("1")
    ]
);

pub fn rsplit(&self, pat: P) -> RSplit<'_, P> ⓘ
where P: JavaStrPattern,

See str::rsplit.

let v: Vec<&JavaStr> = JavaStr::from_str("Mary had a little lamb")
    .rsplit(' ')
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("lamb"),
        JavaStr::from_str("little"),
        JavaStr::from_str("a"),
        JavaStr::from_str("had"),
        JavaStr::from_str("Mary")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("").rsplit('X').collect();
assert_eq!(v, [JavaStr::from_str("")]);

let v: Vec<&JavaStr> = JavaStr::from_str("lionXXtigerXleopard")
    .rsplit('X')
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("leopard"),
        JavaStr::from_str("tiger"),
        JavaStr::from_str(""),
        JavaStr::from_str("lion")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("lion::tiger::leopard")
    .rsplit("::")
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("leopard"),
        JavaStr::from_str("tiger"),
        JavaStr::from_str("lion")
    ]
);

pub fn rsplit_once(&self, delimiter: P) -> Option<(&JavaStr, &JavaStr)>
where P: JavaStrPattern,

See str::rsplit_once.

assert_eq!(JavaStr::from_str("cfg").rsplit_once('='), None);
assert_eq!(
    JavaStr::from_str("cfg=foo").rsplit_once('='),
    Some((JavaStr::from_str("cfg"), JavaStr::from_str("foo")))
);
assert_eq!(
    JavaStr::from_str("cfg=foo=bar").rsplit_once('='),
    Some((JavaStr::from_str("cfg=foo"), JavaStr::from_str("bar")))
);

pub fn rsplit_terminator(&self, pat: P) -> RSplitTerminator<'_, P> ⓘ
where P: JavaStrPattern,

See str::rsplit_terminator.

let v: Vec<&JavaStr> = JavaStr::from_str("A.B.").rsplit_terminator('.').collect();
assert_eq!(v, [JavaStr::from_str("B"), JavaStr::from_str("A")]);

let v: Vec<&JavaStr> = JavaStr::from_str("A..B..").rsplit_terminator(".").collect();
assert_eq!(
    v,
    [
        JavaStr::from_str(""),
        JavaStr::from_str("B"),
        JavaStr::from_str(""),
        JavaStr::from_str("A")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("A.B:C.D")
    .rsplit_terminator(&['.', ':'][..])
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("D"),
        JavaStr::from_str("C"),
        JavaStr::from_str("B"),
        JavaStr::from_str("A")
    ]
);

pub fn rsplitn(&self, n: usize, pat: P) -> RSplitN<'_, P> ⓘ
where P: JavaStrPattern,

See str::rsplitn.

let v: Vec<&JavaStr> = JavaStr::from_str("Mary had a little lamb")
    .rsplitn(3, ' ')
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("lamb"),
        JavaStr::from_str("little"),
        JavaStr::from_str("Mary had a")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("lionXXtigerXleopard")
    .rsplitn(3, 'X')
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("leopard"),
        JavaStr::from_str("tiger"),
        JavaStr::from_str("lionX")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("lion::tiger::leopard")
    .rsplitn(2, "::")
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("leopard"),
        JavaStr::from_str("lion::tiger")
    ]
);

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

See str::split.

let v: Vec<&JavaStr> = JavaStr::from_str("Mary had a little lamb")
    .split(' ')
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("Mary"),
        JavaStr::from_str("had"),
        JavaStr::from_str("a"),
        JavaStr::from_str("little"),
        JavaStr::from_str("lamb")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("").split('X').collect();
assert_eq!(v, [JavaStr::from_str("")]);

let v: Vec<&JavaStr> = JavaStr::from_str("lionXXtigerXleopard")
    .split('X')
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("lion"),
        JavaStr::from_str(""),
        JavaStr::from_str("tiger"),
        JavaStr::from_str("leopard")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("lion::tiger::leopard")
    .split("::")
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("lion"),
        JavaStr::from_str("tiger"),
        JavaStr::from_str("leopard")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("abc1def2ghi")
    .split(JavaCodePoint::is_numeric)
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("abc"),
        JavaStr::from_str("def"),
        JavaStr::from_str("ghi")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("lionXtigerXleopard")
    .split(JavaCodePoint::is_uppercase)
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("lion"),
        JavaStr::from_str("tiger"),
        JavaStr::from_str("leopard")
    ]
);

pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_> ⓘ

See str::split_ascii_whitespace.

let mut iter = JavaStr::from_str(" Mary   had\ta little  \n\t lamb").split_ascii_whitespace();
assert_eq!(Some(JavaStr::from_str("Mary")), iter.next());
assert_eq!(Some(JavaStr::from_str("had")), iter.next());
assert_eq!(Some(JavaStr::from_str("a")), iter.next());
assert_eq!(Some(JavaStr::from_str("little")), iter.next());
assert_eq!(Some(JavaStr::from_str("lamb")), iter.next());

assert_eq!(None, iter.next());

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

See str::split_at.

let s = JavaStr::from_str("Per Martin-Löf");

let (first, last) = s.split_at(3);

assert_eq!("Per", first);
assert_eq!(" Martin-Löf", last);

let s = JavaStr::from_str("Per Martin-Löf");
// Should panic
let _ = s.split_at(13);

pub fn split_at_mut(&mut self, mid: usize) -> (&mut JavaStr, &mut JavaStr)

See str::split_at_mut.

let mut s = JavaString::from("Per Martin-Löf");
let s = s.as_mut_java_str();

let (first, last) = s.split_at_mut(3);

assert_eq!("Per", first);
assert_eq!(" Martin-Löf", last);

let mut s = JavaString::from("Per Martin-Löf");
let s = s.as_mut_java_str();
// Should panic
let _ = s.split_at(13);

pub fn split_inclusive(&self, pat: P) -> SplitInclusive<'_, P> ⓘ
where P: JavaStrPattern,

See str::split_inclusive.

let v: Vec<&JavaStr> = JavaStr::from_str("Mary had a little lamb\nlittle lamb\nlittle lamb.\n")
    .split_inclusive('\n')
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("Mary had a little lamb\n"),
        JavaStr::from_str("little lamb\n"),
        JavaStr::from_str("little lamb.\n")
    ]
);

pub fn split_once(&self, delimiter: P) -> Option<(&JavaStr, &JavaStr)>
where P: JavaStrPattern,

See str::split_once.

assert_eq!(JavaStr::from_str("cfg").split_once('='), None);
assert_eq!(
    JavaStr::from_str("cfg=").split_once('='),
    Some((JavaStr::from_str("cfg"), JavaStr::from_str("")))
);
assert_eq!(
    JavaStr::from_str("cfg=foo").split_once('='),
    Some((JavaStr::from_str("cfg"), JavaStr::from_str("foo")))
);
assert_eq!(
    JavaStr::from_str("cfg=foo=bar").split_once('='),
    Some((JavaStr::from_str("cfg"), JavaStr::from_str("foo=bar")))
);

pub fn split_terminator(&self, pat: P) -> SplitTerminator<'_, P> ⓘ
where P: JavaStrPattern,

See str::split_terminator.

let v: Vec<&JavaStr> = JavaStr::from_str("A.B.").split_terminator('.').collect();
assert_eq!(v, [JavaStr::from_str("A"), JavaStr::from_str("B")]);

let v: Vec<&JavaStr> = JavaStr::from_str("A..B..").split_terminator(".").collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("A"),
        JavaStr::from_str(""),
        JavaStr::from_str("B"),
        JavaStr::from_str("")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("A.B:C.D")
    .split_terminator(&['.', ':'][..])
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("A"),
        JavaStr::from_str("B"),
        JavaStr::from_str("C"),
        JavaStr::from_str("D")
    ]
);

pub fn split_whitespace(&self) -> SplitWhitespace<'_> ⓘ

See str::split_whitespace.

pub fn splitn(&self, n: usize, pat: P) -> SplitN<'_, P> ⓘ
where P: JavaStrPattern,

See str::splitn.

let v: Vec<&JavaStr> = JavaStr::from_str("Mary had a little lambda")
    .splitn(3, ' ')
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("Mary"),
        JavaStr::from_str("had"),
        JavaStr::from_str("a little lambda")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("lionXXtigerXleopard")
    .splitn(3, "X")
    .collect();
assert_eq!(
    v,
    [
        JavaStr::from_str("lion"),
        JavaStr::from_str(""),
        JavaStr::from_str("tigerXleopard")
    ]
);

let v: Vec<&JavaStr> = JavaStr::from_str("abcXdef").splitn(1, 'X').collect();
assert_eq!(v, [JavaStr::from_str("abcXdef")]);

let v: Vec<&JavaStr> = JavaStr::from_str("").splitn(1, 'X').collect();
assert_eq!(v, [JavaStr::from_str("")]);

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

See str::starts_with.

let bananas = JavaStr::from_str("bananas");

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));

pub fn strip_prefix(&self, prefix: P) -> Option<&JavaStr>
where P: JavaStrPattern,

See str::strip_prefix.

assert_eq!(
    JavaStr::from_str("foo:bar").strip_prefix("foo:"),
    Some(JavaStr::from_str("bar"))
);
assert_eq!(JavaStr::from_str("foo:bar").strip_prefix("bar"), None);
assert_eq!(
    JavaStr::from_str("foofoo").strip_prefix("foo"),
    Some(JavaStr::from_str("foo"))
);

pub fn strip_suffix(&self, suffix: P) -> Option<&JavaStr>
where P: JavaStrPattern,

See str::strip_suffix.

assert_eq!(
    JavaStr::from_str("bar:foo").strip_suffix(":foo"),
    Some(JavaStr::from_str("bar"))
);
assert_eq!(JavaStr::from_str("bar:foo").strip_suffix("bar"), None);
assert_eq!(
    JavaStr::from_str("foofoo").strip_suffix("foo"),
    Some(JavaStr::from_str("foo"))
);

pub fn to_ascii_lowercase(&self) -> JavaString

See str::to_ascii_lowercase.

pub fn to_ascii_uppercase(&self) -> JavaString

See str::to_ascii_uppercase.

pub fn to_lowercase(&self) -> JavaString

See str::to_lowercase.

let s = JavaStr::from_str("HELLO");
assert_eq!("hello", s.to_lowercase());

let odysseus = JavaStr::from_str("ὈΔΥΣΣΕΎΣ");
assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());

let s = JavaString::from("Hello ")
    + JavaString::from(JavaCodePoint::from_u32(0xd800).unwrap()).as_java_str()
    + JavaStr::from_str(" World!");
let expected = JavaString::from("hello ")
    + JavaString::from(JavaCodePoint::from_u32(0xd800).unwrap()).as_java_str()
    + JavaStr::from_str(" world!");
assert_eq!(expected, s.to_lowercase());

pub fn to_uppercase(&self) -> JavaString

See str::to_uppercase.

let s = JavaStr::from_str("hello");
assert_eq!("HELLO", s.to_uppercase());

let s = JavaStr::from_str("tschüß");
assert_eq!("TSCHÜSS", s.to_uppercase());

let s = JavaString::from("Hello ")
    + JavaString::from(JavaCodePoint::from_u32(0xd800).unwrap()).as_java_str()
    + JavaStr::from_str(" World!");
let expected = JavaString::from("HELLO ")
    + JavaString::from(JavaCodePoint::from_u32(0xd800).unwrap()).as_java_str()
    + JavaStr::from_str(" WORLD!");
assert_eq!(expected, s.to_uppercase());

pub fn trim(&self) -> &JavaStr

See str::trim.

pub fn trim_end(&self) -> &JavaStr

See str::trim_end.

pub fn trim_end_matches(&self, pat: P) -> &JavaStr
where P: JavaStrPattern,

See str::trim_end_matches.

assert_eq!(
    JavaStr::from_str("11foo1bar11").trim_end_matches('1'),
    "11foo1bar"
);
assert_eq!(
    JavaStr::from_str("123foo1bar123").trim_end_matches(JavaCodePoint::is_numeric),
    "123foo1bar"
);

let x: &[_] = &['1', '2'];
assert_eq!(
    JavaStr::from_str("12foo1bar12").trim_end_matches(x),
    "12foo1bar"
);

pub fn trim_matches(&self, pat: P) -> &JavaStr
where P: JavaStrPattern,

See str::trim_matches.

assert_eq!(
    JavaStr::from_str("11foo1bar11").trim_matches('1'),
    "foo1bar"
);
assert_eq!(
    JavaStr::from_str("123foo1bar123").trim_matches(JavaCodePoint::is_numeric),
    "foo1bar"
);

let x: &[_] = &['1', '2'];
assert_eq!(JavaStr::from_str("12foo1bar12").trim_matches(x), "foo1bar");

pub fn trim_start(&self) -> &JavaStr

See str::trim_start.

pub fn trim_start_matches(&self, pat: P) -> &JavaStr
where P: JavaStrPattern,

See str::trim_start_matches.

assert_eq!(
    JavaStr::from_str("11foo1bar11").trim_start_matches('1'),
    "foo1bar11"
);
assert_eq!(
    JavaStr::from_str("123foo1bar123").trim_start_matches(JavaCodePoint::is_numeric),
    "foo1bar123"
);

let x: &[_] = &['1', '2'];
assert_eq!(
    JavaStr::from_str("12foo1bar12").trim_start_matches(x),
    "foo1bar12"
);

Trait Implementations§

impl<'a> Add<&JavaStr> for Cow<'a, JavaStr>

type Output = Cow<'a, JavaStr>

The resulting type after applying the + operator.

fn add(self, rhs: &JavaStr) -> Self::Output

Performs the + operation. Read more

impl Add<&JavaStr> for JavaString

type Output = JavaString

The resulting type after applying the + operator.

fn add(self, rhs: &JavaStr) -> Self::Output

Performs the + operation. Read more

impl<'a> AddAssign<&JavaStr> for Cow<'a, JavaStr>

fn add_assign(&mut self, rhs: &JavaStr)

Performs the += operation. Read more

impl AddAssign<&JavaStr> for JavaString

fn add_assign(&mut self, rhs: &JavaStr)

Performs the += operation. Read more

impl AsMut<JavaStr> for JavaString

fn as_mut(&mut self) -> &mut JavaStr

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[u8]> for JavaStr

fn as_ref(&self) -> &[u8] ⓘ

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<JavaStr> for Drain<'_>

fn as_ref(&self) -> &JavaStr

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<JavaStr> for JavaStr

fn as_ref(&self) -> &JavaStr

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<JavaStr> for JavaString

fn as_ref(&self) -> &JavaStr

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<JavaStr> for String

fn as_ref(&self) -> &JavaStr

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<JavaStr> for str

fn as_ref(&self) -> &JavaStr

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<JavaStr> for JavaString

fn borrow(&self) -> &JavaStr

Immutably borrows from an owned value. Read more

impl BorrowMut<JavaStr> for JavaString

fn borrow_mut(&mut self) -> &mut JavaStr

Mutably borrows from an owned value. Read more

impl Clone for Box<JavaStr>

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl Debug for JavaStr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl Default for &JavaStr

fn default() -> Self

Returns the “default value” for a type. Read more

impl Default for Box<JavaStr>

fn default() -> Self

Returns the “default value” for a type. Read more

impl<'de: 'a, 'a> Deserialize<'de> for &'a JavaStr

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

impl Display for JavaStr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl<'a> Extend<&'a JavaStr> for JavaString

fn extend<T: IntoIterator<Item = &'a JavaStr>>(&mut self, iter: T)

Extends a collection with the contents of an iterator. Read more

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements. Read more

impl From<&JavaStr> for Arc<JavaStr>

fn from(value: &JavaStr) -> Self

Converts to this type from the input type.

impl From<&JavaStr> for Box<JavaStr>

fn from(value: &JavaStr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a JavaStr> for Cow<'a, JavaStr>

fn from(value: &'a JavaStr) -> Self

Converts to this type from the input type.

impl From<&JavaStr> for JavaString

fn from(value: &JavaStr) -> Self

Converts to this type from the input type.

impl From<&JavaStr> for Rc<JavaStr>

fn from(value: &JavaStr) -> Self

Converts to this type from the input type.

impl From<&JavaStr> for Vec<u8>

fn from(value: &JavaStr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a String> for &'a JavaStr

fn from(value: &'a String) -> Self

Converts to this type from the input type.

impl From<&mut JavaStr> for JavaString

fn from(value: &mut JavaStr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a str> for &'a JavaStr

fn from(value: &'a str) -> Self

Converts to this type from the input type.

impl From<Cow<'_, JavaStr>> for Box<JavaStr>

fn from(value: Cow<'_, JavaStr>) -> Self

Converts to this type from the input type.

impl From<JavaString> for Box<JavaStr>

fn from(value: JavaString) -> Self

Converts to this type from the input type.

impl Hash for JavaStr

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher. Read more

impl Index for JavaStr
where I: JavaStrSliceIndex,

type Output = JavaStr

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation. Read more

impl IndexMut for JavaStr
where I: JavaStrSliceIndex,

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation. Read more

impl JavaStrPattern for &JavaStr

fn prefix_len_in(&mut self, haystack: &JavaStr) -> Option<usize>

fn suffix_len_in(&mut self, haystack: &JavaStr) -> Option<usize>

fn find_in(&mut self, haystack: &JavaStr) -> Option<(usize, usize)>

fn rfind_in(&mut self, haystack: &JavaStr) -> Option<(usize, usize)>

impl Ord for JavaStr

fn cmp(&self, other: &JavaStr) -> Ordering

This method returns an Ordering between self and other. Read more

impl<'a, 'b> PartialEq<&'b JavaStr> for Cow<'a, JavaStr>

fn eq(&self, other: &&'b JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<&'b JavaStr> for Cow<'a, str>

fn eq(&self, other: &&'b JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<&'a JavaStr> for JavaStr

fn eq(&self, other: &&'a JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<&'a JavaStr> for JavaString

fn eq(&self, other: &&'a JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<&'a str> for JavaStr

fn eq(&self, other: &&'a str) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<Cow<'a, JavaStr>> for &'b JavaStr

fn eq(&self, other: &Cow<'a, JavaStr>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<Cow<'a, JavaStr>> for JavaStr

fn eq(&self, other: &Cow<'a, JavaStr>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b JavaStr

fn eq(&self, other: &Cow<'a, str>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<Cow<'a, str>> for JavaStr

fn eq(&self, other: &Cow<'a, str>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<JavaStr> for &'a JavaStr

fn eq(&self, other: &JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<JavaStr> for &'a str

fn eq(&self, other: &JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<JavaStr> for Cow<'a, JavaStr>

fn eq(&self, other: &JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<JavaStr> for Cow<'a, str>

fn eq(&self, other: &JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<JavaStr> for JavaString

fn eq(&self, other: &JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<JavaStr> for String

fn eq(&self, other: &JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<JavaStr> for str

fn eq(&self, other: &JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<JavaString> for &'a JavaStr

fn eq(&self, other: &JavaString) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<JavaString> for JavaStr

fn eq(&self, other: &JavaString) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<String> for &'a JavaStr

fn eq(&self, other: &String) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<String> for JavaStr

fn eq(&self, other: &String) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for JavaStr

fn eq(&self, other: &str) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for JavaStr

fn eq(&self, other: &JavaStr) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for JavaStr

fn partial_cmp(&self, other: &JavaStr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl Serialize for JavaStr

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more

impl ToOwned for JavaStr

type Owned = JavaString

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning. Read more

1.63.0 · source§

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl Eq for JavaStr

impl StructuralPartialEq for JavaStr

Auto Trait Implementations§

impl Freeze for JavaStr

impl RefUnwindSafe for JavaStr

impl Send for JavaStr

impl !Sized for JavaStr

impl Sync for JavaStr

impl Unpin for JavaStr

impl UnwindSafe for JavaStr

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> ToString for T
where T: Display + ?Sized,