Struct janetrs::JanetBuffer
source · pub struct JanetBuffer<'data> { /* private fields */ }
Expand description
Janet buffers are the mutable
version of JanetStrings
. Since Janet strings can hold any sequence of bytes,
including zeros, buffers share this same property and can be used to hold any
arbitrary memory, which makes them very simple but versatile data structures. They can
be used to accumulate small strings into a large string, to implement a bitset, or to
represent sound or images in a program.
§Examples
You can create a JanetBuffer
from a Rust string literal.
use janetrs::JanetBuffer;
let hello = JanetBuffer::from("Hello, world!");
You can append a char
to a JanetBuffer with the push
method, and append a
str
with the push_str
method:
use janetrs::JanetBuffer;
let mut buff = JanetBuffer::from("Hello, ");
buff.push('w');
buff.push_str("orld!");
You can also append a arbitrary sized unsigned integers with push_u8
,
push_u16
, push_u32
, push_u64
:
use janetrs::JanetBuffer;
let mut buff = JanetBuffer::with_capacity(20);
buff.push_u8(10);
buff.push_u16(60000);
buff.push_u32(u32::MAX);
buff.push_u64(u64::MIN);
Implementations§
source§impl JanetBuffer<'_>
impl JanetBuffer<'_>
sourcepub fn new() -> Self
pub fn new() -> Self
Creates a empty JanetBuffer
.
It is initially created with capacity 4, so it will not allocate until it is first pushed into.
§Examples
use janetrs::JanetBuffer;
let buff = JanetBuffer::new();
sourcepub fn with_capacity(capacity: i32) -> Self
pub fn with_capacity(capacity: i32) -> Self
Create a empty JanetBuffer
given to Janet the specified capacity
.
When capacity
is lesser than four, it’s the same as calling with capacity
equals to four.
§Examples
use janetrs::JanetBuffer;
let buff = JanetBuffer::with_capacity(10);
sourcepub const unsafe fn from_raw(raw: *mut CJanetBuffer) -> Self
pub const unsafe fn from_raw(raw: *mut CJanetBuffer) -> Self
Create a new JanetBuffer
with a raw
pointer.
§Safety
This function do not check if the given raw
is NULL
or not. Use at your
own risk.
sourcepub fn capacity(&self) -> i32
pub fn capacity(&self) -> i32
Returns the number of elements the buffer can hold without reallocating.
sourcepub fn len(&self) -> i32
pub fn len(&self) -> i32
Returns the number of elements in the buffer, also referred to as its ‘length’.
§Examples
use janetrs::JanetBuffer;
let mut buff = JanetBuffer::new();
assert_eq!(buff.len(), 0);
buff.push('c');
assert_eq!(buff.len(), 1);
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if the buffer contains no elements.
§Examples
use janetrs::JanetBuffer;
let mut buff = JanetBuffer::new();
assert!(buff.is_empty());
buff.push('1');
assert!(!buff.is_empty());
sourcepub fn set_len(&mut self, new_len: i32)
pub fn set_len(&mut self, new_len: i32)
Set the length of the buffer to new_len
.
If new_len
is greater than the current
buffer length, this append null character (‘\0’) values into the buffer, and if
new_len
is lesser than the current buffer length, the Janet garbage
collector will handle the bytes not used anymore, that’s the reason this
function is safe to call compared to the Rust String
method with the same
name.
This functions does nothing if new_len
is lesser than zero.
Note that this method has no effect on the allocated capacity of the buffer.
sourcepub fn ensure(&mut self, check_capacity: i32, growth: i32)
pub fn ensure(&mut self, check_capacity: i32, growth: i32)
Ensure that a buffer has enough space for check_capacity
elements. If not,
resize the backing memory to capacity
* growth
slots. In most cases, growth
should be 1
or 2
.
sourcepub fn reserve(&mut self, additional: i32)
pub fn reserve(&mut self, additional: i32)
Ensures that this JanetBuffer
’s capacity is at least additional
bytes
larger than its length.
The capacity may be increased by more than additional
bytes if it
chooses, to prevent frequent reallocations.
If you do not want this “at least” behavior, see the reserve_exact
method.
§Panics
Panics if the new capacity overflows i32
.
sourcepub fn reserve_exact(&mut self, additional: i32)
pub fn reserve_exact(&mut self, additional: i32)
sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Truncates this JanetBuffer
, removing all contents.
While this means the string will have a length of zero, it does not touch its capacity.
sourcepub fn push_bytes(&mut self, bytes: &[u8])
pub fn push_bytes(&mut self, bytes: &[u8])
Append the given byte slice onto the end of the buffer.
If the bytes
have a length bigger than i32::MAX
, it will push only the first
i32::MAX
values.
sourcepub fn push_char(&mut self, ch: char)
pub fn push_char(&mut self, ch: char)
Appends the given char to the end of this buffer.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let mut s = JanetBuffer::from("abc");
s.push_char('1');
s.push_char('2');
s.push_char('3');
assert_eq!(s.as_bytes(), "abc123".as_bytes());
sourcepub fn push_str(&mut self, string: &str)
pub fn push_str(&mut self, string: &str)
Append the given string slice onto the end of the buffer.
sourcepub fn push_janet_string(&mut self, string: &JanetString<'_>)
pub fn push_janet_string(&mut self, string: &JanetString<'_>)
Append the given JanetString
onto the end of the buffer
sourcepub fn push_cstr(&mut self, cstr: &CStr)
pub fn push_cstr(&mut self, cstr: &CStr)
Append the given c-string slice onto the end of the buffer.
sourcepub fn as_bytes(&self) -> &[u8] ⓘ
pub fn as_bytes(&self) -> &[u8] ⓘ
Returns a byte slice of the JanetBuffer
contents.
§Examples
use janetrs::JanetBuffer;
let buff = JanetBuffer::from("hello");
assert_eq!(&[104, 101, 108, 108, 111], buff.as_bytes());
sourcepub fn as_bytes_mut(&mut self) -> &mut [u8] ⓘ
pub fn as_bytes_mut(&mut self) -> &mut [u8] ⓘ
Returns a mutable byte slice of the JanetBuffer
contents.
§Examples
use janetrs::JanetBuffer;
let mut buff = JanetBuffer::from("hello");
assert_eq!(&mut [104, 101, 108, 108, 111], buff.as_bytes_mut());
sourcepub fn contains(&self, needle: impl AsRef<[u8]>) -> bool
pub fn contains(&self, needle: impl AsRef<[u8]>) -> bool
Returns true
if and only if this buffer contains the given needle
.
§Examples
use janetrs::JanetBuffer;
let buff = JanetBuffer::from("Hey there");
assert!(buff.contains("the"))
sourcepub fn starts_with(&self, prefix: impl AsRef<[u8]>) -> bool
pub fn starts_with(&self, prefix: impl AsRef<[u8]>) -> bool
Returns true
if and only if this buffer has the given prefix
.
§Examples
use janetrs::JanetBuffer;
assert!(JanetBuffer::from("foo bar").starts_with("foo"));
assert!(!JanetBuffer::from("foo bar").starts_with("bar"));
assert!(!JanetBuffer::from("foo bar").starts_with("foobar"));
sourcepub fn ends_with(&self, suffix: impl AsRef<[u8]>) -> bool
pub fn ends_with(&self, suffix: impl AsRef<[u8]>) -> bool
Returns true
if and only if this buffer has the given suffix
.
§Examples
use janetrs::JanetBuffer;
assert!(!JanetBuffer::from("foo bar").ends_with("foo"));
assert!(JanetBuffer::from("foo bar").ends_with("bar"));
assert!(!JanetBuffer::from("foo bar").ends_with("foobar"));
sourcepub fn is_ascii(&self) -> bool
pub fn is_ascii(&self) -> bool
Returns true
if and only if every byte in this buffer is ASCII.
ASCII is an encoding that defines 128 codepoints. A byte corresponds to
an ASCII codepoint if and only if it is in the inclusive range
[0, 127]
.
§Examples
use janetrs::JanetBuffer;
assert!(JanetBuffer::from("abc").is_ascii());
assert!(!JanetBuffer::from("☃βツ").is_ascii());
sourcepub fn is_utf8(&self) -> bool
pub fn is_utf8(&self) -> bool
Returns true
if and only if the entire buffer is valid UTF-8.
If you need location information about where a buffer’s first
invalid UTF-8 byte is, then use the to_str
method.
§Examples
use janetrs::JanetBuffer;
assert!(JanetBuffer::from("abc").is_utf8());
assert!(JanetBuffer::from("☃βツ").is_utf8());
// invalid bytes
assert!(!JanetBuffer::from(&b"abc\xFF"[..]).is_utf8());
// surrogate encoding
assert!(!JanetBuffer::from(&b"\xED\xA0\x80"[..]).is_utf8());
// incomplete sequence
assert!(!JanetBuffer::from(&b"\xF0\x9D\x9Ca"[..]).is_utf8());
// overlong sequence
assert!(!JanetBuffer::from(&b"\xF0\x82\x82\xAC"[..]).is_utf8());
sourcepub fn to_lowercase(&self) -> Self
Available on crate feature unicode
only.
pub fn to_lowercase(&self) -> Self
unicode
only.Returns a new JanetBuffer
containing the lowercase equivalent of this
buffer.
In this case, lowercase is defined according to the Lowercase
Unicode
property.
If invalid UTF-8 is seen, or if a character has no lowercase variant, then it is written to the given buffer unchanged.
Note that some characters in this buffer may expand into multiple characters when changing the case, so the number of bytes written to the given buffer may not be equivalent to the number of bytes in this buffer.
If you’d like to reuse an allocation for performance reasons, then use
to_lowercase_into
instead.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("HELLO Β");
assert_eq!("hello β".as_bytes(), s.to_lowercase().as_bytes());
Scripts without case are not changed:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("农历新年");
assert_eq!("农历新年".as_bytes(), s.to_lowercase().as_bytes());
Invalid UTF-8 remains as is:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(&b"FOO\xFFBAR\xE2\x98BAZ"[..]);
assert_eq!(&b"foo\xFFbar\xE2\x98baz"[..], s.to_lowercase().as_bytes());
sourcepub fn to_lowercase_into(&self, buf: &mut Self)
Available on crate feature unicode
only.
pub fn to_lowercase_into(&self, buf: &mut Self)
unicode
only.Writes the lowercase equivalent of this buffer into the given buffer. The buffer is not cleared before written to.
In this case, lowercase is defined according to the Lowercase
Unicode property.
If invalid UTF-8 is seen, or if a character has no lowercase variant, then it is written to the given buffer unchanged.
Note that some characters in this buffer may expand into multiple characters when changing the case, so the number of bytes written to the given buffer may not be equivalent to the number of bytes in this buffer.
If you don’t need to amortize allocation and instead prefer
convenience, then use to_lowercase
instead.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("HELLO Β");
let mut buf = JanetBuffer::new();
s.to_lowercase_into(&mut buf);
assert_eq!("hello β".as_bytes(), buf.as_bytes());
Scripts without case are not changed:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("农历新年");
let mut buf = JanetBuffer::new();
s.to_lowercase_into(&mut buf);
assert_eq!("农历新年".as_bytes(), buf.as_bytes());
Invalid UTF-8 remains as is:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(&b"FOO\xFFBAR\xE2\x98BAZ"[..]);
let mut buf = JanetBuffer::new();
s.to_lowercase_into(&mut buf);
assert_eq!(&b"foo\xFFbar\xE2\x98baz"[..], buf.as_bytes());
sourcepub fn to_ascii_lowercase(&self) -> Self
pub fn to_ascii_lowercase(&self) -> Self
Returns a new JanetBuffer
containing the ASCII lowercase equivalent of
this buffer.
In this case, lowercase is only defined in ASCII letters. Namely, the
letters A-Z
are converted to a-z
. All other bytes remain unchanged.
In particular, the length of the buffer returned is always
equivalent to the length of this buffer.
If you’d like to reuse an allocation for performance reasons, then use
make_ascii_lowercase
to perform
the conversion in place.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("HELLO Β");
assert_eq!("hello Β".as_bytes(), s.to_ascii_lowercase().as_bytes());
Invalid UTF-8 remains as is:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(&b"FOO\xFFBAR\xE2\x98BAZ"[..]);
assert_eq!(
s.to_ascii_lowercase().as_bytes(),
&b"foo\xFFbar\xE2\x98baz"[..]
);
sourcepub fn make_ascii_lowercase(&mut self)
pub fn make_ascii_lowercase(&mut self)
Convert this buffer to its lowercase ASCII equivalent in place.
In this case, lowercase is only defined in ASCII letters. Namely, the
letters A-Z
are converted to a-z
. All other bytes remain unchanged.
If you don’t need to do the conversion in
place and instead prefer convenience, then use
to_ascii_lowercase
instead.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let mut s = JanetBuffer::from("HELLO Β");
s.make_ascii_lowercase();
assert_eq!(s.as_bytes(), "hello Β".as_bytes());
Invalid UTF-8 remains as is:
use janetrs::JanetBuffer;
let mut s = JanetBuffer::from(&b"FOO\xFFBAR\xE2\x98BAZ"[..]);
s.make_ascii_lowercase();
assert_eq!(s.as_bytes(), &b"foo\xFFbar\xE2\x98baz"[..]);
sourcepub fn to_uppercase(&self) -> Self
Available on crate feature unicode
only.
pub fn to_uppercase(&self) -> Self
unicode
only.Returns a new JanetBuffer
containing the uppercase equivalent of this
buffer.
In this case, uppercase is defined according to the Uppercase
Unicode property.
If invalid UTF-8 is seen, or if a character has no uppercase variant, then it is written to the given buffer unchanged.
Note that some characters in this buffer may expand into multiple characters when changing the case, so the number of bytes written to the given buffer may not be equivalent to the number of bytes in this buffer.
If you’d like to reuse an allocation for performance reasons, then use
to_uppercase_into
instead.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("hello β");
assert_eq!(s.to_uppercase().as_bytes(), "HELLO Β".as_bytes());
Scripts without case are not changed:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("农历新年");
assert_eq!(s.to_uppercase().as_bytes(), "农历新年".as_bytes());
Invalid UTF-8 remains as is:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(&b"foo\xFFbar\xE2\x98baz"[..]);
assert_eq!(
s.to_uppercase().as_bytes(),
JanetBuffer::from(&b"FOO\xFFBAR\xE2\x98BAZ"[..]).as_bytes()
);
sourcepub fn to_uppercase_into(&self, buf: &mut Self)
Available on crate feature unicode
only.
pub fn to_uppercase_into(&self, buf: &mut Self)
unicode
only.Writes the uppercase equivalent of this buffer into the given buffer. The buffer is not cleared before written to.
In this case, uppercase is defined according to the Uppercase
Unicode property.
If invalid UTF-8 is seen, or if a character has no uppercase variant, then it is written to the given buffer unchanged.
Note that some characters in this buffer may expand into multiple characters when changing the case, so the number of bytes written to the given buffer may not be equivalent to the number of bytes in this buffer.
If you don’t need to amortize allocation and instead prefer
convenience, then use to_uppercase
instead.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("hello β");
let mut buf = JanetBuffer::new();
s.to_uppercase_into(&mut buf);
assert_eq!(buf.as_bytes(), "HELLO Β".as_bytes());
Scripts without case are not changed:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("农历新年");
let mut buf = JanetBuffer::new();
s.to_uppercase_into(&mut buf);
assert_eq!(buf.as_bytes(), "农历新年".as_bytes());
Invalid UTF-8 remains as is:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(&b"foo\xFFbar\xE2\x98baz"[..]);
let mut buf = JanetBuffer::new();
s.to_uppercase_into(&mut buf);
assert_eq!(buf.as_bytes(), &b"FOO\xFFBAR\xE2\x98BAZ"[..]);
sourcepub fn to_ascii_uppercase(&self) -> Self
pub fn to_ascii_uppercase(&self) -> Self
Returns a new JanetBuffer
containing the ASCII uppercase equivalent of
this buffer.
In this case, uppercase is only defined in ASCII letters. Namely, the
letters a-z
are converted to A-Z
. All other bytes remain unchanged.
In particular, the length of the buffer returned is always
equivalent to the length of this buffer.
If you’d like to reuse an allocation for performance reasons, then use
make_ascii_uppercase
to perform
the conversion in place.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("hello β");
assert_eq!(s.to_ascii_uppercase().as_bytes(), "HELLO β".as_bytes());
Invalid UTF-8 remains as is:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(&b"foo\xFFbar\xE2\x98baz"[..]);
assert_eq!(
s.to_ascii_uppercase().as_bytes(),
&b"FOO\xFFBAR\xE2\x98BAZ"[..]
);
sourcepub fn make_ascii_uppercase(&mut self)
pub fn make_ascii_uppercase(&mut self)
Convert this buffer to its uppercase ASCII equivalent in place.
In this case, uppercase is only defined in ASCII letters. Namely, the
letters a-z
are converted to A-Z
. All other bytes remain unchanged.
If you don’t need to do the conversion in
place and instead prefer convenience, then use
to_ascii_uppercase
instead.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let mut s = JanetBuffer::from("hello β");
s.make_ascii_uppercase();
assert_eq!(s.as_bytes(), "HELLO β".as_bytes());
Invalid UTF-8 remains as is:
use janetrs::JanetBuffer;
let mut s = JanetBuffer::from(&b"foo\xFFbar\xE2\x98baz"[..]);
s.make_ascii_uppercase();
assert_eq!(s.as_bytes(), &b"FOO\xFFBAR\xE2\x98BAZ"[..]);
sourcepub fn trim(&self) -> Self
Available on crate feature unicode
only.
pub fn trim(&self) -> Self
unicode
only.Return a buffer with leading and trailing whitespace removed.
Whitespace is defined according to the terms of the White_Space
Unicode property.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(" foo\tbar\t\u{2003}\n");
assert_eq!(
s.trim().as_bytes(),
JanetBuffer::from("foo\tbar").as_bytes()
);
sourcepub fn trim_start(&self) -> Self
Available on crate feature unicode
only.
pub fn trim_start(&self) -> Self
unicode
only.Return a buffer with leading whitespace removed.
Whitespace is defined according to the terms of the White_Space
Unicode property.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(" foo\tbar\t\u{2003}\n");
assert_eq!(
s.trim_start().as_bytes(),
JanetBuffer::from("foo\tbar\t\u{2003}\n").as_bytes()
);
sourcepub fn trim_end(&self) -> Self
Available on crate feature unicode
only.
pub fn trim_end(&self) -> Self
unicode
only.Return a buffer with trailing whitespace removed.
Whitespace is defined according to the terms of the White_Space
Unicode property.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(" foo\tbar\t\u{2003}\n");
assert_eq!(
s.trim_end().as_bytes(),
JanetBuffer::from(" foo\tbar").as_bytes()
);
sourcepub fn trim_with<F: FnMut(char) -> bool>(&self, trim: F) -> Self
pub fn trim_with<F: FnMut(char) -> bool>(&self, trim: F) -> Self
Return a buffer with leading and trailing characters satisfying the given predicate removed.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("123foo5bar789");
assert_eq!(
s.trim_with(|c| c.is_numeric()).as_bytes(),
JanetBuffer::from("foo5bar").as_bytes(),
);
sourcepub fn trim_start_with<F: FnMut(char) -> bool>(&self, trim: F) -> Self
pub fn trim_start_with<F: FnMut(char) -> bool>(&self, trim: F) -> Self
Return a buffer with leading characters satisfying the given predicate removed.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("123foo5bar789");
assert_eq!(
s.trim_start_with(|c| c.is_numeric()).as_bytes(),
JanetBuffer::from("foo5bar789").as_bytes()
);
sourcepub fn trim_end_with<F: FnMut(char) -> bool>(&self, trim: F) -> Self
pub fn trim_end_with<F: FnMut(char) -> bool>(&self, trim: F) -> Self
Return a buffer with trailing characters satisfying the given predicate removed.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("123foo5bar");
assert_eq!(
s.trim_end_with(|c| c.is_numeric()).as_bytes(),
JanetBuffer::from("123foo5bar").as_bytes()
);
sourcepub fn to_str(&self) -> Result<&str, Utf8Error>
pub fn to_str(&self) -> Result<&str, Utf8Error>
Safely convert this buffer into a &str
if it’s valid UTF-8.
If this buffer is not valid UTF-8, then an error is returned. The error returned indicates the first invalid byte found and the length of the error.
In cases where a lossy conversion to &str
is acceptable, then use one
of the to_str_lossy
or
to_str_lossy_into
methods.
sourcepub unsafe fn to_str_unchecked(&self) -> &str
pub unsafe fn to_str_unchecked(&self) -> &str
Unsafely convert this buffer into a &str
, without checking for
valid UTF-8.
§Safety
Callers must ensure that this buffer is valid UTF-8 before
calling this method. Converting a buffer into a &str
that is
not valid UTF-8 is considered undefined behavior.
This routine is useful in performance sensitive contexts where the
UTF-8 validity of the buffer is already known and it is
undesirable to pay the cost of an additional UTF-8 validation check
that to_str
performs.
sourcepub fn to_str_lossy(&self) -> Cow<'_, str>
pub fn to_str_lossy(&self) -> Cow<'_, str>
Convert this buffer to a valid UTF-8 string by replacing invalid
UTF-8 bytes with the Unicode replacement codepoint (U+FFFD
).
If the buffer is already valid UTF-8, then no copying or allocation is performed and a borrowed string slice is returned. If the buffer is not valid UTF-8, then an owned string buffer is returned with invalid bytes replaced by the replacement codepoint.
This method uses the “substitution of maximal subparts” (Unicode Standard, Chapter 3, Section 9) strategy for inserting the replacement codepoint. Specifically, a replacement codepoint is inserted whenever a byte is found that cannot possibly lead to a valid code unit sequence. If there were previous bytes that represented a prefix of a well-formed code unit sequence, then all of those bytes are substituted with a single replacement codepoint. The “substitution of maximal subparts” strategy is the same strategy used by W3C’s Encoding standard. For a more precise description of the maximal subpart strategy, see the Unicode Standard, Chapter 3, Section 9. See also Public Review Issue #121.
N.B. Rust’s standard library also appears to use the same strategy, but it does not appear to be an API guarantee.
sourcepub fn to_str_lossy_into(&self, dest: &mut String)
pub fn to_str_lossy_into(&self, dest: &mut String)
Copy the contents of this buffer into the given owned string
buffer, while replacing invalid UTF-8 code unit sequences with the
Unicode replacement codepoint (U+FFFD
).
This method uses the same “substitution of maximal subparts” strategy
for inserting the replacement codepoint as the
to_str_lossy
method.
This routine is useful for amortizing allocation. However, unlike
to_str_lossy
, this routine will always copy the contents of this
buffer into the destination buffer, even if this buffer is
valid UTF-8.
sourcepub fn to_os_str(&self) -> Result<&OsStr, Utf8Error>
Available on crate feature std
only.
pub fn to_os_str(&self) -> Result<&OsStr, Utf8Error>
std
only.Create an OS string slice from this buffer.
On Unix, this always succeeds and is zero cost. On non-Unix systems, this returns a UTF-8 decoding error if this buffer is not valid UTF-8. (For example, on Windows, file paths are allowed to be a sequence of arbitrary 16-bit integers. There is no obvious mapping from an arbitrary sequence of 8-bit integers to an arbitrary sequence of 16-bit integers.)
sourcepub fn to_os_str_lossy(&self) -> Cow<'_, OsStr>
Available on crate feature std
only.
pub fn to_os_str_lossy(&self) -> Cow<'_, OsStr>
std
only.Lossily create an OS string slice from this buffer.
On Unix, this always succeeds and is zero cost. On non-Unix systems, this will perform a UTF-8 check and lossily convert this buffer into valid UTF-8 using the Unicode replacement codepoint.
Note that this can prevent the correct roundtripping of file paths on non-Unix systems such as Windows, where file paths are an arbitrary sequence of 16-bit integers.
sourcepub fn to_path(&self) -> Result<&Path, Utf8Error>
Available on crate feature std
only.
pub fn to_path(&self) -> Result<&Path, Utf8Error>
std
only.Create a path slice from this buffer.
On Unix, this always succeeds and is zero cost. On non-Unix systems, this returns a UTF-8 decoding error if this buffer is not valid UTF-8. (For example, on Windows, file paths are allowed to be a sequence of arbitrary 16-bit integers. There is no obvious mapping from an arbitrary sequence of 8-bit integers to an arbitrary sequence of 16-bit integers.)
sourcepub fn to_path_lossy(&self) -> Cow<'_, Path>
Available on crate feature std
only.
pub fn to_path_lossy(&self) -> Cow<'_, Path>
std
only.Lossily create a path slice from this buffer.
On Unix, this always succeeds and is zero cost. On non-Unix systems, this will perform a UTF-8 check and lossily convert this buffer into valid UTF-8 using the Unicode replacement codepoint.
Note that this can prevent the correct roundtripping of file paths on non-Unix systems such as Windows, where file paths are an arbitrary sequence of 16-bit integers.
sourcepub fn find(&self, needle: impl AsRef<[u8]>) -> Option<usize>
pub fn find(&self, needle: impl AsRef<[u8]>) -> Option<usize>
Returns the index of the first occurrence of the given needle
.
The needle
may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
.
§Complexity
This routine is guaranteed to have worst case linear time complexity
with respect to both the needle
and the haystack. That is, this runs
in O(needle.len() + haystack.len())
time.
This routine is also guaranteed to have worst case constant space complexity.
§Examples
use janetrs::JanetBuffer;
let s = JanetBuffer::from("foo bar baz");
assert_eq!(Some(0), s.find("foo"));
assert_eq!(Some(4), s.find("bar"));
assert_eq!(None, s.find("quux"));
sourcepub fn rfind(&self, needle: impl AsRef<[u8]>) -> Option<usize>
pub fn rfind(&self, needle: impl AsRef<[u8]>) -> Option<usize>
Returns the index of the last occurrence of the given needle
.
The needle
may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
.
§Complexity
This routine is guaranteed to have worst case linear time complexity
with respect to both the needle
and the haystack. That is, this runs
in O(needle.len() + haystack.len())
time.
This routine is also guaranteed to have worst case constant space complexity.
§Examples
use janetrs::JanetBuffer;
let s = JanetBuffer::from("foo bar baz");
assert_eq!(Some(0), s.rfind("foo"));
assert_eq!(Some(4), s.rfind("bar"));
assert_eq!(Some(8), s.rfind("ba"));
assert_eq!(None, s.rfind("quux"));
sourcepub fn find_byte(&self, byte: u8) -> Option<usize>
pub fn find_byte(&self, byte: u8) -> Option<usize>
Returns the index of the first occurrence of the given byte. If the
byte does not occur in this buffer, then None
is returned.
§Examples
use janetrs::JanetBuffer;
assert_eq!(Some(10), JanetBuffer::from("foo bar baz").find_byte(b'z'));
assert_eq!(None, JanetBuffer::from("foo bar baz").find_byte(b'y'));
sourcepub fn rfind_byte(&self, byte: u8) -> Option<usize>
pub fn rfind_byte(&self, byte: u8) -> Option<usize>
Returns the index of the last occurrence of the given byte
. If the
byte
does not occur in this buffer, then None
is returned.
§Examples
use janetrs::JanetBuffer;
assert_eq!(Some(10), JanetBuffer::from("foo bar baz").rfind_byte(b'z'));
assert_eq!(None, JanetBuffer::from("foo bar baz").rfind_byte(b'y'));
sourcepub fn find_char(&self, ch: char) -> Option<usize>
pub fn find_char(&self, ch: char) -> Option<usize>
Returns the index of the first occurrence of the given codepoint.
If the codepoint does not occur in this buffer, then None
is
returned.
Note that if one searches for the replacement codepoint, \u{FFFD}
,
then only explicit occurrences of that encoding will be found. Invalid
UTF-8 sequences will not be matched.
§Examples
use janetrs::JanetBuffer;
assert_eq!(Some(10), JanetBuffer::from("foo bar baz").find_char('z'));
assert_eq!(Some(4), JanetBuffer::from("αβγγδ").find_char('γ'));
assert_eq!(None, JanetBuffer::from("foo bar baz").find_char('y'));
sourcepub fn rfind_char(&self, ch: char) -> Option<usize>
pub fn rfind_char(&self, ch: char) -> Option<usize>
Returns the index of the last occurrence of the given codepoint.
If the codepoint does not occur in this buffer, then None
is
returned.
Note that if one searches for the replacement codepoint, \u{FFFD}
,
then only explicit occurrences of that encoding will be found. Invalid
UTF-8 sequences will not be matched.
§Examples
use janetrs::JanetBuffer;
assert_eq!(Some(10), JanetBuffer::from("foo bar baz").rfind_char('z'));
assert_eq!(Some(6), JanetBuffer::from("αβγγδ").rfind_char('γ'));
assert_eq!(None, JanetBuffer::from("foo bar baz").rfind_char('y'));
sourcepub fn find_byteset(&self, byteset: impl AsRef<[u8]>) -> Option<usize>
pub fn find_byteset(&self, byteset: impl AsRef<[u8]>) -> Option<usize>
Returns the index of the first occurrence of any of the bytes in the provided set.
The byteset
may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
, but
note that passing a &str
which contains multibyte characters may not
behave as you expect: each byte in the &str
is treated as an
individual member of the byte set.
Note that order is irrelevant for the byteset
parameter, and
duplicate bytes present in its body are ignored.
§Complexity
This routine is guaranteed to have worst case linear time complexity
with respect to both the set of bytes and the haystack. That is, this
runs in O(byteset.len() + haystack.len())
time.
This routine is also guaranteed to have worst case constant space complexity.
§Examples
use janetrs::JanetBuffer;
assert_eq!(
JanetBuffer::from("foo bar baz").find_byteset(b"zr"),
Some(6)
);
assert_eq!(
JanetBuffer::from("foo baz bar").find_byteset(b"bzr"),
Some(4)
);
assert_eq!(None, JanetBuffer::from("foo baz bar").find_byteset(b"\t\n"));
sourcepub fn find_not_byteset(&self, byteset: impl AsRef<[u8]>) -> Option<usize>
pub fn find_not_byteset(&self, byteset: impl AsRef<[u8]>) -> Option<usize>
Returns the index of the first occurrence of a byte that is not a member of the provided set.
The byteset
may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
, but
note that passing a &str
which contains multibyte characters may not
behave as you expect: each byte in the &str
is treated as an
individual member of the byte set.
Note that order is irrelevant for the byteset
parameter, and
duplicate bytes present in its body are ignored.
§Complexity
This routine is guaranteed to have worst case linear time complexity
with respect to both the set of bytes and the haystack. That is, this
runs in O(byteset.len() + haystack.len())
time.
This routine is also guaranteed to have worst case constant space complexity.
§Examples
use janetrs::JanetBuffer;
assert_eq!(
JanetBuffer::from("foo bar baz").find_not_byteset(b"fo "),
Some(4)
);
assert_eq!(
JanetBuffer::from("\t\tbaz bar").find_not_byteset(b" \t\r\n"),
Some(2)
);
assert_eq!(
JanetBuffer::from("foo\nbaz\tbar").find_not_byteset(b"\t\n"),
Some(0)
);
sourcepub fn rfind_byteset(&self, byteset: impl AsRef<[u8]>) -> Option<usize>
pub fn rfind_byteset(&self, byteset: impl AsRef<[u8]>) -> Option<usize>
Returns the index of the last occurrence of any of the bytes in the provided set.
The byteset
may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
, but
note that passing a &str
which contains multibyte characters may not
behave as you expect: each byte in the &str
is treated as an
individual member of the byte set.
Note that order is irrelevant for the byteset
parameter, and duplicate
bytes present in its body are ignored.
§Complexity
This routine is guaranteed to have worst case linear time complexity
with respect to both the set of bytes and the haystack. That is, this
runs in O(byteset.len() + haystack.len())
time.
This routine is also guaranteed to have worst case constant space complexity.
§Examples
use janetrs::JanetBuffer;
assert_eq!(
JanetBuffer::from("foo bar baz").rfind_byteset(b"agb"),
Some(9)
);
assert_eq!(
JanetBuffer::from("foo baz bar").rfind_byteset(b"rabz "),
Some(10)
);
assert_eq!(
JanetBuffer::from("foo baz bar").rfind_byteset(b"\n123"),
None
);
sourcepub fn rfind_not_byteset(&self, byteset: impl AsRef<[u8]>) -> Option<usize>
pub fn rfind_not_byteset(&self, byteset: impl AsRef<[u8]>) -> Option<usize>
Returns the index of the last occurrence of a byte that is not a member of the provided set.
The byteset
may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
, but
note that passing a &str
which contains multibyte characters may not
behave as you expect: each byte in the &str
is treated as an
individual member of the byte set.
Note that order is irrelevant for the byteset
parameter, and
duplicate bytes present in its body are ignored.
§Complexity
This routine is guaranteed to have worst case linear time complexity
with respect to both the set of bytes and the haystack. That is, this
runs in O(byteset.len() + haystack.len())
time.
This routine is also guaranteed to have worst case constant space complexity.
§Examples
use janetrs::JanetBuffer;
assert_eq!(
JanetBuffer::from("foo bar baz,\t").rfind_not_byteset(b",\t"),
Some(10)
);
assert_eq!(
JanetBuffer::from("foo baz bar").rfind_not_byteset(b"rabz "),
Some(2)
);
assert_eq!(
None,
JanetBuffer::from("foo baz bar").rfind_not_byteset(b"barfoz ")
);
sourcepub fn find_iter<'a, 'b, B: ?Sized + AsRef<[u8]>>(
&'a self,
needle: &'b B
) -> Find<'a, 'b>
pub fn find_iter<'a, 'b, B: ?Sized + AsRef<[u8]>>( &'a self, needle: &'b B ) -> Find<'a, 'b>
Creates an iterator of the non-overlapping occurrences of the given
needle
. The iterator yields byte offset positions indicating the start
of each match.
§Complexity
This routine is guaranteed to have worst case linear time complexity
with respect to both the needle and the haystack. That is, this runs
in O(needle.len() + haystack.len())
time.
This routine is also guaranteed to have worst case constant space complexity.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from("foo bar foo foo quux foo");
let matches: Vec<usize> = buff.find_iter("foo").collect();
assert_eq!(matches, vec![0, 8, 12, 21]);
An empty string matches at every position, including the position immediately following the last byte:
use janetrs::JanetBuffer;
let matches: Vec<usize> = JanetBuffer::from("foo").find_iter("").collect();
assert_eq!(matches, vec![0, 1, 2, 3]);
let matches: Vec<usize> = JanetBuffer::from("").find_iter("").collect();
assert_eq!(matches, vec![0]);
sourcepub fn rfind_iter<'a, 'b, B>(&'a self, needle: &'b B) -> FindReverse<'a, 'b>
pub fn rfind_iter<'a, 'b, B>(&'a self, needle: &'b B) -> FindReverse<'a, 'b>
Creates an iterator of the non-overlapping occurrences of the given
needle
in reverse. The iterator yields byte offset positions indicating
the start of each match.
§Complexity
This routine is guaranteed to have worst case linear time complexity
with respect to both the needle and the haystack. That is, this runs
in O(needle.len() + haystack.len())
time.
This routine is also guaranteed to have worst case constant space complexity.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from("foo bar foo foo quux foo");
let matches: Vec<usize> = buff.rfind_iter("foo").collect();
assert_eq!(matches, vec![21, 12, 8, 0]);
An empty string matches at every position, including the position immediately following the last byte:
use janetrs::JanetBuffer;
let matches: Vec<usize> = JanetBuffer::from("foo").rfind_iter("").collect();
assert_eq!(matches, vec![3, 2, 1, 0]);
let matches: Vec<usize> = JanetBuffer::from("").rfind_iter("").collect();
assert_eq!(matches, vec![0]);
sourcepub fn bytes(&self) -> Bytes<'_>
pub fn bytes(&self) -> Bytes<'_>
Creates an iterator over the bytes of the JanetBuffer
.
§Examples
use janetrs::JanetBuffer;
let buff = JanetBuffer::from("Hello");
assert_eq!(buff.bytes().collect::<Vec<u8>>(), b"Hello");
sourcepub fn chars(&self) -> Chars<'_>
pub fn chars(&self) -> Chars<'_>
Creates an iterator over the Unicode scalar values in this buffer. If invalid UTF-8 is encountered, then the Unicode replacement codepoint is yielded instead.
§Examples
use janetrs::JanetBuffer;
let s = JanetBuffer::from(&b"\xE2\x98\x83\xFF\xF0\x9D\x9E\x83\xE2\x98\x61"[..]);
let chars: Vec<char> = s.chars().collect();
assert_eq!(vec!['☃', '\u{FFFD}', '𝞃', '\u{FFFD}', 'a'], chars);
sourcepub fn char_indices(&self) -> CharIndices<'_>
pub fn char_indices(&self) -> CharIndices<'_>
Creates an iterator over the Unicode scalar values in this janet buffer along with their starting and ending byte index positions. If invalid UTF-8 is encountered, then the Unicode replacement codepoint is yielded instead.
Note that this is slightly different from the CharIndices
iterator provided by
the standard library. Aside from working on possibly invalid UTF-8, this
iterator provides both the corresponding starting and ending byte indices of
each codepoint yielded. The ending position is necessary to slice the original
buffer when invalid UTF-8 bytes are converted into a Unicode replacement
codepoint, since a single replacement codepoint can substitute anywhere from 1
to 3 invalid bytes (inclusive).
§Examples
use janetrs::JanetBuffer;
let s = JanetBuffer::from(&b"\xE2\x98\x83\xFF\xF0\x9D\x9E\x83\xE2\x98\x61"[..]);
let chars: Vec<(usize, usize, char)> = s.char_indices().collect();
assert_eq!(chars, vec![
(0, 3, '☃'),
(3, 4, '\u{FFFD}'),
(4, 8, '𝞃'),
(8, 10, '\u{FFFD}'),
(10, 11, 'a'),
]);
sourcepub fn fields(&self) -> Fields<'_>
Available on crate feature unicode
only.
pub fn fields(&self) -> Fields<'_>
unicode
only.Creates an iterator over the fields in a buffer, separated by contiguous whitespace.
§Example
Basic usage:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(" foo\tbar\t\u{2003}\nquux \n");
let fields: Vec<&[u8]> = buff.fields().collect();
assert_eq!(fields, vec![
"foo".as_bytes(),
"bar".as_bytes(),
"quux".as_bytes()
]);
A buffer consisting of just whitespace yields no elements:
use janetrs::JanetBuffer;
assert_eq!(
0,
JanetBuffer::from(" \n\t\u{2003}\n \t").fields().count()
);
sourcepub fn fields_with<F>(&self, f: F) -> FieldsWith<'_, F>
pub fn fields_with<F>(&self, f: F) -> FieldsWith<'_, F>
Creates an iterator over the fields in a buffer, separated by contiguous codepoints satisfying the given predicate.
If this string is not valid UTF-8, then the given closure will be called with a Unicode replacement codepoint when invalid UTF-8 bytes are seen.
§Example
Basic usage:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from("123foo999999bar1quux123456");
let fields: Vec<&[u8]> = buff.fields_with(|c| c.is_numeric()).collect();
assert_eq!(fields, vec![
"foo".as_bytes(),
"bar".as_bytes(),
"quux".as_bytes()
]);
A buffer consisting of all codepoints satisfying the predicate yields no elements:
use janetrs::JanetBuffer;
assert_eq!(
0,
JanetBuffer::from("1911354563")
.fields_with(|c| c.is_numeric())
.count()
);
sourcepub fn grapheme_indices(&self) -> GraphemeIndices<'_>
Available on crate feature unicode
only.
pub fn grapheme_indices(&self) -> GraphemeIndices<'_>
unicode
only.Creates an iterator over the grapheme clusters in this buffer along with their starting and ending byte index positions. If invalid UTF-8 is encountered, then the Unicode replacement codepoint is yielded instead.
§Examples
This example shows how to get the byte offsets of each individual grapheme cluster:
use janetrs::JanetBuffer;
let bs = JanetBuffer::from("a\u{0300}\u{0316}\u{1F1FA}\u{1F1F8}");
let graphemes: Vec<(usize, usize, &str)> = bs.grapheme_indices().collect();
assert_eq!(vec![(0, 5, "à̖"), (5, 13, "🇺🇸")], graphemes);
This example shows what happens when invalid UTF-8 is encountered. Note
that the offsets are valid indices into the original string, and do
not necessarily correspond to the length of the &str
returned!
use janetrs::JanetBuffer;
let mut bytes = JanetBuffer::new();
bytes.push_str("a\u{0300}\u{0316}");
bytes.push_u8(b'\xFF');
bytes.push_str("\u{1F1FA}\u{1F1F8}");
let graphemes: Vec<(usize, usize, &str)> = bytes.grapheme_indices().collect();
assert_eq!(graphemes, vec![
(0, 5, "à̖"),
(5, 6, "\u{FFFD}"),
(6, 14, "🇺🇸")
]);
sourcepub fn graphemes(&self) -> Graphemes<'_>
Available on crate feature unicode
only.
pub fn graphemes(&self) -> Graphemes<'_>
unicode
only.Creates an iterator over the grapheme clusters in this buffer. If invalid UTF-8 is encountered, then the Unicode replacement codepoint is yielded instead.
§Examples
This example shows how multiple codepoints can combine to form a single grapheme cluster:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from("a\u{0300}\u{0316}\u{1F1FA}\u{1F1F8}");
let graphemes: Vec<&str> = buff.graphemes().collect();
assert_eq!(vec!["à̖", "🇺🇸"], graphemes);
This shows that graphemes can be iterated over in reverse:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from("a\u{0300}\u{0316}\u{1F1FA}\u{1F1F8}");
let graphemes: Vec<&str> = buff.graphemes().rev().collect();
assert_eq!(vec!["🇺🇸", "à̖"], graphemes);
sourcepub fn lines(&self) -> Lines<'_>
pub fn lines(&self) -> Lines<'_>
Creates an iterator over all lines in a buffer, without their terminators.
For this iterator, the only line terminators recognized are \r\n
and
\n
.
§Examples
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(
&b"\
foo
bar\r
baz
quux"[..],
);
let lines: Vec<&[u8]> = buff.lines().collect();
assert_eq!(lines, vec![
&b"foo"[..],
&b""[..],
&b"bar"[..],
&b"baz"[..],
&b""[..],
&b""[..],
&b"quux"[..],
]);
sourcepub fn lines_with_terminator(&self) -> LinesWithTerminator<'_>
pub fn lines_with_terminator(&self) -> LinesWithTerminator<'_>
Creates an iterator over all lines in a buffer, including their terminators.
For this iterator, the only line terminator recognized is \n
. (Since
line terminators are included, this also handles \r\n
line endings.)
Line terminators are only included if they are present in the original buffer. For example, the last line in a buffer may not end with a line terminator.
Concatenating all elements yielded by this iterator is guaranteed to yield the original buffer.
§Examples
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(
&b"\
foo
bar\r
baz
quux"[..],
);
let lines: Vec<&[u8]> = buff.lines_with_terminator().collect();
assert_eq!(lines, vec![
&b"foo\n"[..],
&b"\n"[..],
&b"bar\r\n"[..],
&b"baz\n"[..],
&b"\n"[..],
&b"\n"[..],
&b"quux"[..],
]);
sourcepub fn sentence_indices(&self) -> SentenceIndices<'_>
Available on crate feature unicode
only.
pub fn sentence_indices(&self) -> SentenceIndices<'_>
unicode
only.Creates an iterator over the sentences in this buffer along with their starting and ending byte index positions.
Typically, a sentence will include its trailing punctuation and whitespace. Concatenating all elements yielded by the iterator results in the original string (modulo Unicode replacement codepoint substitutions if invalid UTF-8 is encountered).
Since sentences are made up of one or more codepoints, this iterator
yields &str
elements. When invalid UTF-8 is encountered, replacement
codepoints are substituted.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(&b"I want this. Not that. Right now."[..]);
let sentences: Vec<(usize, usize, &str)> = buff.sentence_indices().collect();
assert_eq!(sentences, vec![
(0, 13, "I want this. "),
(13, 23, "Not that. "),
(23, 33, "Right now."),
]);
sourcepub fn sentences(&self) -> Sentences<'_>
Available on crate feature unicode
only.
pub fn sentences(&self) -> Sentences<'_>
unicode
only.Creates an iterator over the sentences in this buffer.
Typically, a sentence will include its trailing punctuation and whitespace. Concatenating all elements yielded by the iterator results in the original string (modulo Unicode replacement codepoint substitutions if invalid UTF-8 is encountered).
Since sentences are made up of one or more codepoints, this iterator
yields &str
elements. When invalid UTF-8 is encountered, replacement
codepoints are substituted.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(&b"I want this. Not that. Right now."[..]);
let sentences: Vec<&str> = buff.sentences().collect();
assert_eq!(
sentences,
vec!["I want this. ", "Not that. ", "Right now.",]
);
sourcepub fn split<'a, 'b, S>(&'a self, splitter: &'b S) -> Split<'a, 'b>
pub fn split<'a, 'b, S>(&'a self, splitter: &'b S) -> Split<'a, 'b>
Creates an iterator over substrings of this buffer, separated by the given buffer. Each element yielded is guaranteed not to include the splitter substring.
The splitter may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("Mary had a little lamb");
let x: Vec<&[u8]> = s.split(" ").collect();
assert_eq!(x, vec![
&b"Mary"[..],
&b"had"[..],
&b"a"[..],
&b"little"[..],
&b"lamb"[..],
]);
let s = JanetBuffer::from("");
let x: Vec<&[u8]> = s.split("X").collect();
assert_eq!(x, vec![&b""[..]]);
let s = JanetBuffer::from("lionXXtigerXleopard");
let x: Vec<&[u8]> = s.split("X").collect();
assert_eq!(x, vec![
&b"lion"[..],
&b""[..],
&b"tiger"[..],
&b"leopard"[..]
]);
let s = JanetBuffer::from("lion::tiger::leopard");
let x: Vec<&[u8]> = s.split("::").collect();
assert_eq!(x, vec![&b"lion"[..], &b"tiger"[..], &b"leopard"[..]]);
If a string contains multiple contiguous separators, you will end up with empty strings yielded by the iterator:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("||||a||b|c");
let x: Vec<&[u8]> = s.split("|").collect();
assert_eq!(x, vec![
&b""[..],
&b""[..],
&b""[..],
&b""[..],
&b"a"[..],
&b""[..],
&b"b"[..],
&b"c"[..],
]);
let s = JanetBuffer::from("(///)");
let x: Vec<&[u8]> = s.split("/").collect();
assert_eq!(x, vec![&b"("[..], &b""[..], &b""[..], &b")"[..]]);
Separators at the start or end of a string are neighbored by empty strings.
use janetrs::JanetBuffer;
let s = JanetBuffer::from("010");
let x: Vec<&[u8]> = s.split("0").collect();
assert_eq!(x, vec![&b""[..], &b"1"[..], &b""[..]]);
When the empty string is used as a separator, it splits every byte in the string, along with the beginning and end of the string.
use janetrs::JanetBuffer;
let s = JanetBuffer::from("rust");
let x: Vec<&[u8]> = s.split("").collect();
assert_eq!(x, vec![
&b""[..],
&b"r"[..],
&b"u"[..],
&b"s"[..],
&b"t"[..],
&b""[..]
]);
// Splitting by an empty string is not UTF-8 aware. Elements yielded
// may not be valid UTF-8!
let s = JanetBuffer::from("☃");
let x: Vec<&[u8]> = s.split("").collect();
assert_eq!(x, vec![
&b""[..],
&b"\xE2"[..],
&b"\x98"[..],
&b"\x83"[..],
&b""[..]
]);
Contiguous separators, especially whitespace, can lead to possibly surprising behavior. For example, this code is correct:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(" a b c");
let x: Vec<&[u8]> = s.split(" ").collect();
assert_eq!(x, vec![
&b""[..],
&b""[..],
&b""[..],
&b""[..],
&b"a"[..],
&b""[..],
&b"b"[..],
&b"c"[..]
]);
It does not give you ["a", "b", "c"]
. For that behavior, use
fields
instead.
sourcepub fn rsplit<'a, 'b, S>(&'a self, splitter: &'b S) -> SplitReverse<'a, 'b>
pub fn rsplit<'a, 'b, S>(&'a self, splitter: &'b S) -> SplitReverse<'a, 'b>
Creates an iterator over substrings of this buffer, separated by the given buffer. Each element yielded is guaranteed not to include the splitter substring.
The splitter may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("Mary had a little lamb");
let x: Vec<&[u8]> = s.rsplit(" ").collect();
assert_eq!(x, vec![
&b"lamb"[..],
&b"little"[..],
&b"a"[..],
&b"had"[..],
&b"Mary"[..],
]);
let s = JanetBuffer::from("");
let x: Vec<&[u8]> = s.rsplit("X").collect();
assert_eq!(x, vec![&b""[..]]);
let s = JanetBuffer::from("lionXXtigerXleopard");
let x: Vec<&[u8]> = s.rsplit("X").collect();
assert_eq!(x, vec![
&b"leopard"[..],
&b"tiger"[..],
&b""[..],
&b"lion"[..],
]);
let s = JanetBuffer::from("lion::tiger::leopard");
let x: Vec<&[u8]> = s.rsplit("::").collect();
assert_eq!(x, vec![&b"leopard"[..], &b"tiger"[..], &b"lion"[..]]);
If a buffer contains multiple contiguous separators, you will end up with empty strings yielded by the iterator:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("||||a||b|c");
let x: Vec<&[u8]> = s.rsplit("|").collect();
assert_eq!(x, vec![
&b"c"[..],
&b"b"[..],
&b""[..],
&b"a"[..],
&b""[..],
&b""[..],
&b""[..],
&b""[..],
]);
let s = JanetBuffer::from("(///)");
let x: Vec<&[u8]> = s.rsplit("/").collect();
assert_eq!(x, vec![&b")"[..], &b""[..], &b""[..], &b"("[..]]);
Separators at the start or end of a string are neighbored by empty strings.
use janetrs::JanetBuffer;
let s = JanetBuffer::from("010");
let x: Vec<&[u8]> = s.rsplit("0").collect();
assert_eq!(x, vec![&b""[..], &b"1"[..], &b""[..]]);
When the empty string is used as a separator, it splits every byte in the string, along with the beginning and end of the string.
use janetrs::JanetBuffer;
let s = JanetBuffer::from("rust");
let x: Vec<&[u8]> = s.rsplit("").collect();
assert_eq!(x, vec![
&b""[..],
&b"t"[..],
&b"s"[..],
&b"u"[..],
&b"r"[..],
&b""[..]
]);
// Splitting by an empty string is not UTF-8 aware. Elements yielded
// may not be valid UTF-8!
let s = JanetBuffer::from("☃");
let x: Vec<&[u8]> = s.rsplit("").collect();
assert_eq!(x, vec![
&b""[..],
&b"\x83"[..],
&b"\x98"[..],
&b"\xE2"[..],
&b""[..]
]);
Contiguous separators, especially whitespace, can lead to possibly surprising behavior. For example, this code is correct:
use janetrs::JanetBuffer;
let s = JanetBuffer::from(" a b c");
let x: Vec<&[u8]> = s.rsplit(" ").collect();
assert_eq!(x, vec![
&b"c"[..],
&b"b"[..],
&b""[..],
&b"a"[..],
&b""[..],
&b""[..],
&b""[..],
&b""[..],
]);
It does not give you ["a", "b", "c"]
.
sourcepub fn splitn<'a, 'b, S>(
&'a self,
limit: usize,
splitter: &'b S
) -> SplitN<'a, 'b>
pub fn splitn<'a, 'b, S>( &'a self, limit: usize, splitter: &'b S ) -> SplitN<'a, 'b>
Creates an iterator of at most limit
substrings of this buffer,
separated by the given string. If limit
substrings are yielded,
then the last substring will contain the remainder of this buffer.
The needle may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("Mary had a little lamb");
let x: Vec<_> = s.splitn(3, " ").collect();
assert_eq!(x, vec![&b"Mary"[..], &b"had"[..], &b"a little lamb"[..]]);
let s = JanetBuffer::from("");
let x: Vec<_> = s.splitn(3, "X").collect();
assert_eq!(x, vec![b""]);
let s = JanetBuffer::from("lionXXtigerXleopard");
let x: Vec<_> = s.splitn(3, "X").collect();
assert_eq!(x, vec![&b"lion"[..], &b""[..], &b"tigerXleopard"[..]]);
let s = JanetBuffer::from("lion::tiger::leopard");
let x: Vec<_> = s.splitn(2, "::").collect();
assert_eq!(x, vec![&b"lion"[..], &b"tiger::leopard"[..]]);
let s = JanetBuffer::from("abcXdef");
let x: Vec<_> = s.splitn(1, "X").collect();
assert_eq!(x, vec![&b"abcXdef"[..]]);
let s = JanetBuffer::from("abcdef");
let x: Vec<_> = s.splitn(2, "X").collect();
assert_eq!(x, vec![&b"abcdef"[..]]);
let s = JanetBuffer::from("abcXdef");
let x: Vec<_> = s.splitn(0, "X").collect();
assert!(x.is_empty());
sourcepub fn rsplitn<'a, 'b, S>(
&'a self,
limit: usize,
splitter: &'b S
) -> SplitNReverse<'a, 'b>
pub fn rsplitn<'a, 'b, S>( &'a self, limit: usize, splitter: &'b S ) -> SplitNReverse<'a, 'b>
Creates an iterator of at most limit
substrings of this buffer,
separated by the given string. If limit
substrings are yielded,
then the last substring will contain the remainder of this buffer.
The needle may be any type that can be cheaply converted into a
&[u8]
. This includes, but is not limited to, &str
and &[u8]
.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let s = JanetBuffer::from("Mary had a little lamb");
let x: Vec<_> = s.rsplitn(3, " ").collect();
assert_eq!(x, vec![&b"lamb"[..], &b"little"[..], &b"Mary had a"[..]]);
let s = JanetBuffer::from("");
let x: Vec<_> = s.rsplitn(3, "X").collect();
assert_eq!(x, vec![b""]);
let s = JanetBuffer::from("lionXXtigerXleopard");
let x: Vec<_> = s.rsplitn(3, "X").collect();
assert_eq!(x, vec![&b"leopard"[..], &b"tiger"[..], &b"lionX"[..]]);
let s = JanetBuffer::from("lion::tiger::leopard");
let x: Vec<_> = s.rsplitn(2, "::").collect();
assert_eq!(x, vec![&b"leopard"[..], &b"lion::tiger"[..]]);
let s = JanetBuffer::from("abcXdef");
let x: Vec<_> = s.rsplitn(1, "X").collect();
assert_eq!(x, vec![&b"abcXdef"[..]]);
let s = JanetBuffer::from("abcdef");
let x: Vec<_> = s.rsplitn(2, "X").collect();
assert_eq!(x, vec![&b"abcdef"[..]]);
let s = JanetBuffer::from("abcXdef");
let x: Vec<_> = s.rsplitn(0, "X").collect();
assert!(x.is_empty());
sourcepub fn utf8_chunks(&self) -> Utf8Chunks<'_>
pub fn utf8_chunks(&self) -> Utf8Chunks<'_>
Creates an iterator over chunks of valid UTF-8.
The iterator returned yields chunks of valid UTF-8 separated by invalid
UTF-8 bytes, if they exist. Invalid UTF-8 bytes are always 1-3 bytes,
which are determined via the “substitution of maximal subparts”
strategy described in the docs for the
to_str_lossy
method.
§Examples
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(&b"foo\xFD\xFEbar\xFF"[..]);
let (mut valid_chunks, mut invalid_chunks) = (vec![], vec![]);
for chunk in buff.utf8_chunks() {
if !chunk.valid().is_empty() {
valid_chunks.push(chunk.valid());
}
if !chunk.invalid().is_empty() {
invalid_chunks.push(chunk.invalid());
}
}
assert_eq!(valid_chunks, vec!["foo", "bar"]);
assert_eq!(invalid_chunks, vec![b"\xFD", b"\xFE", b"\xFF"]);
sourcepub fn word_indices(&self) -> WordIndices<'_>
Available on crate feature unicode
only.
pub fn word_indices(&self) -> WordIndices<'_>
unicode
only.Creates an iterator over the words in this buffer along with their starting and ending byte index positions.
This is similar to words_with_break_indices
, except it only returns elements
that contain a “word” character. A word character is defined by UTS #18 (Annex
C) to be the combination of the Alphabetic
and Join_Control
properties,
along with the Decimal_Number
, Mark
and Connector_Punctuation
general
categories.
Since words are made up of one or more codepoints, this iterator
yields &str
elements. When invalid UTF-8 is encountered, replacement
codepoints are substituted.
§Examples
This example shows how to get the byte offsets of each individual word:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(&b"can't jump 32.3 feet"[..]);
let words: Vec<(usize, usize, &str)> = buff.word_indices().collect();
assert_eq!(words, vec![
(0, 5, "can't"),
(6, 10, "jump"),
(11, 15, "32.3"),
(16, 20, "feet"),
]);
sourcepub fn words(&self) -> Words<'_>
Available on crate feature unicode
only.
pub fn words(&self) -> Words<'_>
unicode
only.Creates an iterator over the words in this buffer. If invalid UTF-8 is encountered, then the Unicode replacement codepoint is yielded instead.
This is similar to words_with_breaks
, except it only returns elements that
contain a “word” character. A word character is defined by UTS #18 (Annex C)
to be the combination of the Alphabetic
and Join_Control
properties, along
with the Decimal_Number
, Mark
and Connector_Punctuation
general
categories.
Since words are made up of one or more codepoints, this iterator
yields &str
elements. When invalid UTF-8 is encountered, replacement
codepoints are substituted.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(&br#"The quick ("brown") fox can't jump 32.3 feet, right?"#[..]);
let words: Vec<&str> = buff.words().collect();
assert_eq!(words, vec![
"The", "quick", "brown", "fox", "can't", "jump", "32.3", "feet", "right",
]);
sourcepub fn words_with_break_indices(&self) -> WordsWithBreakIndices<'_>
Available on crate feature unicode
only.
pub fn words_with_break_indices(&self) -> WordsWithBreakIndices<'_>
unicode
only.Creates an iterator over the words and their byte offsets in this buffer, along with all breaks between the words. Concatenating all elements yielded by the iterator results in the original string (modulo Unicode replacement codepoint substitutions if invalid UTF-8 is encountered).
Since words are made up of one or more codepoints, this iterator
yields &str
elements. When invalid UTF-8 is encountered, replacement
codepoints are substituted.
§Examples
This example shows how to get the byte offsets of each individual word:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(&b"can't jump 32.3 feet"[..]);
let words: Vec<(usize, usize, &str)> = buff.words_with_break_indices().collect();
assert_eq!(words, vec![
(0, 5, "can't"),
(5, 6, " "),
(6, 10, "jump"),
(10, 11, " "),
(11, 15, "32.3"),
(15, 16, " "),
(16, 20, "feet"),
]);
sourcepub fn words_with_breaks(&self) -> WordsWithBreaks<'_>
Available on crate feature unicode
only.
pub fn words_with_breaks(&self) -> WordsWithBreaks<'_>
unicode
only.Creates an iterator over the words in this buffer, along with all breaks between the words. Concatenating all elements yielded by the iterator results in the original string (modulo Unicode replacement codepoint substitutions if invalid UTF-8 is encountered).
Since words are made up of one or more codepoints, this iterator
yields &str
elements. When invalid UTF-8 is encountered, replacement
codepoints are substituted.
§Examples
Basic usage:
use janetrs::JanetBuffer;
let buff = JanetBuffer::from(&br#"The quick ("brown") fox can't jump 32.3 feet, right?"#[..]);
let words: Vec<&str> = buff.words_with_breaks().collect();
assert_eq!(words, vec![
"The", " ", "quick", " ", "(", "\"", "brown", "\"", ")", " ", "fox", " ", "can't", " ",
"jump", " ", "32.3", " ", "feet", ",", " ", "right", "?",
]);
sourcepub const fn as_raw(&self) -> *const CJanetBuffer
pub const fn as_raw(&self) -> *const CJanetBuffer
Return a raw pointer to the buffer raw structure.
The caller must ensure that the buffer outlives the pointer this function returns, or else it will end up pointing to garbage.
If you need to mutate the contents of the slice, use as_mut_ptr
.
sourcepub fn as_mut_raw(&mut self) -> *mut CJanetBuffer
pub fn as_mut_raw(&mut self) -> *mut CJanetBuffer
Return a raw mutable pointer to the buffer raw structure.
The caller must ensure that the buffer outlives the pointer this function returns, or else it will end up pointing to garbage.
sourcepub fn as_ptr(&self) -> *const u8
pub fn as_ptr(&self) -> *const u8
Converts a buffer to a raw pointer.
The caller must ensure that the buffer outlives the pointer this function returns, or else it will end up pointing to garbage.
sourcepub fn as_mut_ptr(&mut self) -> *mut u8
pub fn as_mut_ptr(&mut self) -> *mut u8
Converts a mutable buffer slice to a raw pointer.
The caller must ensure that the buffer outlives the pointer this function returns, or else it will end up pointing to garbage.
Trait Implementations§
source§impl AsMut<[u8]> for JanetBuffer<'_>
impl AsMut<[u8]> for JanetBuffer<'_>
source§impl AsMut<BStr> for JanetBuffer<'_>
impl AsMut<BStr> for JanetBuffer<'_>
source§impl AsRef<[u8]> for JanetBuffer<'_>
impl AsRef<[u8]> for JanetBuffer<'_>
source§impl AsRef<BStr> for JanetBuffer<'_>
impl AsRef<BStr> for JanetBuffer<'_>
source§impl Clone for JanetBuffer<'_>
impl Clone for JanetBuffer<'_>
source§impl Debug for JanetBuffer<'_>
impl Debug for JanetBuffer<'_>
source§impl DeepEq<JanetBuffer<'_>> for JanetString<'_>
impl DeepEq<JanetBuffer<'_>> for JanetString<'_>
source§impl DeepEq<JanetString<'_>> for JanetBuffer<'_>
impl DeepEq<JanetString<'_>> for JanetBuffer<'_>
source§impl DeepEq for JanetBuffer<'_>
impl DeepEq for JanetBuffer<'_>
source§impl Default for JanetBuffer<'_>
impl Default for JanetBuffer<'_>
source§impl Display for JanetBuffer<'_>
impl Display for JanetBuffer<'_>
source§impl<'a> Extend<&'a [u8]> for JanetBuffer<'_>
impl<'a> Extend<&'a [u8]> for JanetBuffer<'_>
source§fn extend<T: IntoIterator<Item = &'a [u8]>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = &'a [u8]>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<'a> Extend<&'a char> for JanetBuffer<'_>
impl<'a> Extend<&'a char> for JanetBuffer<'_>
source§fn extend<T: IntoIterator<Item = &'a char>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = &'a char>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<'a> Extend<&'a str> for JanetBuffer<'_>
impl<'a> Extend<&'a str> for JanetBuffer<'_>
source§fn extend<T: IntoIterator<Item = &'a str>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = &'a str>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<'a> Extend<&'a u8> for JanetBuffer<'_>
impl<'a> Extend<&'a u8> for JanetBuffer<'_>
source§fn extend<T: IntoIterator<Item = &'a u8>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = &'a u8>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl Extend<String> for JanetBuffer<'_>
impl Extend<String> for JanetBuffer<'_>
source§fn extend<T: IntoIterator<Item = String>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = String>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl Extend<char> for JanetBuffer<'_>
impl Extend<char> for JanetBuffer<'_>
source§fn extend<T: IntoIterator<Item = char>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = char>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl Extend<u8> for JanetBuffer<'_>
impl Extend<u8> for JanetBuffer<'_>
source§fn extend<T: IntoIterator<Item = u8>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = u8>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl From<&[u8]> for JanetBuffer<'_>
impl From<&[u8]> for JanetBuffer<'_>
source§impl From<&JanetBuffer<'_>> for Janet
impl From<&JanetBuffer<'_>> for Janet
source§fn from(val: &JanetBuffer<'_>) -> Self
fn from(val: &JanetBuffer<'_>) -> Self
source§impl From<&JanetBuffer<'_>> for JanetKeyword<'_>
impl From<&JanetBuffer<'_>> for JanetKeyword<'_>
source§fn from(buff: &JanetBuffer<'_>) -> Self
fn from(buff: &JanetBuffer<'_>) -> Self
source§impl From<&JanetBuffer<'_>> for JanetString<'_>
impl From<&JanetBuffer<'_>> for JanetString<'_>
source§fn from(buff: &JanetBuffer<'_>) -> Self
fn from(buff: &JanetBuffer<'_>) -> Self
source§impl From<&JanetBuffer<'_>> for JanetSymbol<'_>
impl From<&JanetBuffer<'_>> for JanetSymbol<'_>
source§fn from(buff: &JanetBuffer<'_>) -> Self
fn from(buff: &JanetBuffer<'_>) -> Self
source§impl From<&JanetKeyword<'_>> for JanetBuffer<'_>
impl From<&JanetKeyword<'_>> for JanetBuffer<'_>
source§fn from(s: &JanetKeyword<'_>) -> Self
fn from(s: &JanetKeyword<'_>) -> Self
source§impl From<&JanetString<'_>> for JanetBuffer<'_>
impl From<&JanetString<'_>> for JanetBuffer<'_>
source§fn from(s: &JanetString<'_>) -> Self
fn from(s: &JanetString<'_>) -> Self
source§impl From<&JanetSymbol<'_>> for JanetBuffer<'_>
impl From<&JanetSymbol<'_>> for JanetBuffer<'_>
source§fn from(s: &JanetSymbol<'_>) -> Self
fn from(s: &JanetSymbol<'_>) -> Self
source§impl From<&char> for JanetBuffer<'_>
impl From<&char> for JanetBuffer<'_>
source§impl From<&mut JanetBuffer<'_>> for Janet
impl From<&mut JanetBuffer<'_>> for Janet
source§fn from(val: &mut JanetBuffer<'_>) -> Self
fn from(val: &mut JanetBuffer<'_>) -> Self
source§impl From<&str> for JanetBuffer<'_>
impl From<&str> for JanetBuffer<'_>
source§impl From<JanetBuffer<'_>> for Janet
impl From<JanetBuffer<'_>> for Janet
source§fn from(val: JanetBuffer<'_>) -> Self
fn from(val: JanetBuffer<'_>) -> Self
source§impl From<JanetBuffer<'_>> for JanetKeyword<'_>
impl From<JanetBuffer<'_>> for JanetKeyword<'_>
source§fn from(buff: JanetBuffer<'_>) -> Self
fn from(buff: JanetBuffer<'_>) -> Self
source§impl From<JanetBuffer<'_>> for JanetString<'_>
impl From<JanetBuffer<'_>> for JanetString<'_>
source§fn from(buff: JanetBuffer<'_>) -> Self
fn from(buff: JanetBuffer<'_>) -> Self
source§impl From<JanetBuffer<'_>> for JanetSymbol<'_>
impl From<JanetBuffer<'_>> for JanetSymbol<'_>
source§fn from(buff: JanetBuffer<'_>) -> Self
fn from(buff: JanetBuffer<'_>) -> Self
source§impl From<JanetKeyword<'_>> for JanetBuffer<'_>
impl From<JanetKeyword<'_>> for JanetBuffer<'_>
source§fn from(s: JanetKeyword<'_>) -> Self
fn from(s: JanetKeyword<'_>) -> Self
source§impl From<JanetString<'_>> for JanetBuffer<'_>
impl From<JanetString<'_>> for JanetBuffer<'_>
source§fn from(s: JanetString<'_>) -> Self
fn from(s: JanetString<'_>) -> Self
source§impl From<JanetSymbol<'_>> for JanetBuffer<'_>
impl From<JanetSymbol<'_>> for JanetBuffer<'_>
source§fn from(s: JanetSymbol<'_>) -> Self
fn from(s: JanetSymbol<'_>) -> Self
source§impl From<String> for JanetBuffer<'_>
impl From<String> for JanetBuffer<'_>
source§impl From<char> for JanetBuffer<'_>
impl From<char> for JanetBuffer<'_>
source§impl<'a> FromIterator<&'a char> for JanetBuffer<'_>
impl<'a> FromIterator<&'a char> for JanetBuffer<'_>
source§impl<'a> FromIterator<&'a str> for JanetBuffer<'_>
impl<'a> FromIterator<&'a str> for JanetBuffer<'_>
source§impl<'a> FromIterator<&'a u8> for JanetBuffer<'_>
impl<'a> FromIterator<&'a u8> for JanetBuffer<'_>
source§impl FromIterator<String> for JanetBuffer<'_>
impl FromIterator<String> for JanetBuffer<'_>
source§impl FromIterator<char> for JanetBuffer<'_>
impl FromIterator<char> for JanetBuffer<'_>
source§impl FromStr for JanetBuffer<'_>
impl FromStr for JanetBuffer<'_>
source§impl Index<i32> for JanetBuffer<'_>
impl Index<i32> for JanetBuffer<'_>
source§impl IndexMut<i32> for JanetBuffer<'_>
impl IndexMut<i32> for JanetBuffer<'_>
source§impl JanetExtend<&[u8]> for JanetBuffer<'_>
impl JanetExtend<&[u8]> for JanetBuffer<'_>
source§impl JanetExtend<&CStr> for JanetBuffer<'_>
impl JanetExtend<&CStr> for JanetBuffer<'_>
source§impl JanetExtend<&char> for JanetBuffer<'_>
impl JanetExtend<&char> for JanetBuffer<'_>
source§impl JanetExtend<&str> for JanetBuffer<'_>
impl JanetExtend<&str> for JanetBuffer<'_>
source§impl JanetExtend<char> for JanetBuffer<'_>
impl JanetExtend<char> for JanetBuffer<'_>
source§impl JanetTypeName for JanetBuffer<'_>
impl JanetTypeName for JanetBuffer<'_>
source§impl Ord for JanetBuffer<'_>
impl Ord for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<&'a [u8]> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<&'a [u8]> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<&'a BStr> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<&'a BStr> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<&'a BString> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<&'a BString> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<&'a str> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<&'a str> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<[u8]> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<[u8]> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<BStr> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<BStr> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<BString> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<BString> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for &'a [u8]
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for &'a [u8]
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for &'a BStr
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for &'a BStr
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for &'a BString
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for &'a BString
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for &'a str
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for &'a str
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for [u8]
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for [u8]
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for BStr
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for BStr
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for BString
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for BString
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for String
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for String
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for Vec<u8>
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for Vec<u8>
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<JanetBuffer<'_>> for str
impl<'a, 'b> PartialEq<JanetBuffer<'_>> for str
source§fn eq(&self, other: &JanetBuffer<'_>) -> bool
fn eq(&self, other: &JanetBuffer<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<'a, 'b> PartialEq<String> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<String> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<Vec<u8>> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<Vec<u8>> for JanetBuffer<'_>
source§impl<'a, 'b> PartialEq<str> for JanetBuffer<'_>
impl<'a, 'b> PartialEq<str> for JanetBuffer<'_>
source§impl PartialEq for JanetBuffer<'_>
impl PartialEq for JanetBuffer<'_>
source§impl<'a, 'b> PartialOrd<&'a [u8]> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<&'a [u8]> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<&'a BStr> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<&'a BStr> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<&'a BString> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<&'a BString> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<&'a str> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<&'a str> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<[u8]> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<[u8]> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<BStr> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<BStr> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<BString> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<BString> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for &'a [u8]
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for &'a [u8]
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for &'a BStr
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for &'a BStr
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for &'a BString
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for &'a BString
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for &'a str
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for &'a str
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for [u8]
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for [u8]
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for BStr
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for BStr
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for BString
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for BString
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for String
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for String
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for Vec<u8>
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for Vec<u8>
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for str
impl<'a, 'b> PartialOrd<JanetBuffer<'_>> for str
source§fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
fn partial_cmp(&self, other: &JanetBuffer<'_>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<String> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<String> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<Vec<u8>> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<Vec<u8>> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, 'b> PartialOrd<str> for JanetBuffer<'_>
impl<'a, 'b> PartialOrd<str> for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd for JanetBuffer<'_>
impl PartialOrd for JanetBuffer<'_>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read more