Struct TracedDOMString 

#[repr(transparent)]
pub struct TracedDOMString(RefCell<DOMStringType>);

This type corresponds to the DOMString type in WebIDL.

Conceptually, a DOMString has the same value space as a JavaScript String, i.e., an array of 16-bit code units representing UTF-16, potentially with unpaired surrogates present (also sometimes called WTF-16).

However, Rust Strings are guaranteed to be valid UTF-8, and as such have a smaller value space than WTF-16 (i.e., some JavaScript String values can not be represented as a Rust String). This introduces the question of what to do with values being passed from JavaScript to Rust that contain unpaired surrogates.

The hypothesis is that it does not matter much how exactly those values are transformed, because passing unpaired surrogates into the DOM is very rare. Instead Servo will replace the unpaired surrogate by a U+FFFD replacement character.

Currently, the lack of crash reports about this issue provides some evidence to support the hypothesis. This evidence will hopefully be used to convince other browser vendors that it would be safe to replace unpaired surrogates at the boundary between JavaScript and native code. (This would unify the DOMString and USVString types, both in the WebIDL standard and in Servo.)

Note: the above appears refuted by the needs of dom/encoding.

This string class will keep either the Reference to the mozjs object alive or will have an internal rust string. We currently default to doing most of the string operation on the rust side. You should use str() to get the Rust string (represented by a StringView which you can deref to a &str). You should assume that this conversion is expensive. For now, you should assume that all the functions incur this conversion cost.

Tuple Fields

0: RefCell<DOMStringType>

Implementations

impl TracedDOMString

pub fn root(self) -> DOMString

fn ensure_rust_string(&self) -> RefMut<'_, String>

Transforms the internal storage of this DOMString into a Rust string if it is not yet one. This will make a copy of the underlying string data.

fn debug_js(&self, cx: &JSContext)

Debug the current state of the string without modifying it.

pub fn str(&self) -> StringView<'_>

Returns the underlying rust string.

pub fn encoded_bytes<'a>(&'a self, no_gc: &'a NoGC) -> EncodedBytes<'a>

Return the EncodedBytes of this DOMString. This returns the original encoded bytes of the string without doing any conversions.

pub fn clear(&mut self)

pub fn is_empty(&self) -> bool

pub fn len_utf8(&self) -> Utf8CodeUnits

The length of this string in UTF-8 code units, each one being one byte in size. This method is the same as [DOMString::len], but the result is wrapped in a Utf8CodeUnits to be used in code that mixes different kinds of offsets.

Note: This is different than the number of Unicode characters (or code points). A character may require multiple UTF-8 code units.

pub fn len_utf8_or_latin1(&self) -> usize

Returns a length for “is small” heuristics, whose precise definition does not matter

pub fn len_utf16(&self) -> Utf16CodeUnits

The length of this string in UTF-16 code units, each one being one two bytes in size.

Note: This is different than the number of Unicode characters (or code points). A character may require multiple UTF-16 code units.

pub fn make_ascii_lowercase(&mut self)

This works the same as make_ascii_lowercase on std::string. This means that any character in [A-Z] will be transformed to lower case but other characters stay the same (either ASCII or not ASCII).

pub fn push_str(&mut self, string_to_push: &str)

pub fn strip_leading_and_trailing_ascii_whitespace(&mut self)

https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace

pub fn is_valid_floating_point_number_string(&self) -> bool

https://html.spec.whatwg.org/multipage/#valid-floating-point-number

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

pub fn parse_floating_point_number(&self) -> Option<f64>

https://html.spec.whatwg.org/multipage/#rules-for-parsing-floating-point-number-values

pub fn set_best_representation_of_the_floating_point_number(&mut self)

https://html.spec.whatwg.org/multipage/#best-representation-of-the-number-as-a-floating-point-number

pub fn to_lowercase(&self) -> String

pub fn to_uppercase(&self) -> String

pub fn strip_newlines(&mut self)

pub fn normalize_newlines(&mut self)

Normalize newlines according to https://infra.spec.whatwg.org/#normalize-newlines.

pub fn replace(self, needle: &str, replace_char: &str) -> DOMString

pub fn starts_with(&self, c: char) -> bool

Pattern is not yet stable in rust, hence, we need different methods for str and char

pub fn starts_with_str(&self, needle: &str) -> bool

pub fn ends_with_str(&self, needle: &str) -> bool

pub fn contains(&self, needle: &str) -> bool

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

Returns whether this DOMString is an ASCII case-insensitive match for other, without allocating and copying temporaries.

https://infra.spec.whatwg.org/#ascii-case-insensitive

pub fn to_ascii_lowercase(&self) -> String

fn contains_space_characters( &self, latin1_characters: &'static [u8], utf8_characters: &'static [char], ) -> bool

pub fn contains_tab_or_newline(&self) -> bool

https://infra.spec.whatwg.org/#ascii-tab-or-newline

pub fn contains_html_space_characters(&self) -> bool

https://infra.spec.whatwg.org/#ascii-whitespace

pub fn as_bytes<'a>(&'a self, no_gc: &'a NoGC) -> BytesView<'a>

This returns the string in utf8 bytes, i.e., [u8] encoded with utf8.

pub fn is_ascii_lowercase(&self) -> bool

Tests if there are only ascii lowercase characters. Does not include special characters.

pub fn is_ascii(&self) -> bool

Is the string only ascii characters

pub fn is_valid_for_cookie(&self) -> bool

Returns true if the slice only contains bytes that are safe to use in cookie strings. https://www.ietf.org/archive/id/draft-ietf-httpbis-rfc6265bis-15.html#section-5.6-6 Not using ServoCookie::is_valid_name_or_value to prevent dependency on the net crate.

fn with_str_reference<Result>(&self, callback: fn(&str) -> Result) -> Result

Call the callback with a &str reference of the string stored in this DOMString. Note that if the DOMString cannot be interpreted as a Rust string a conversion will be done.

pub fn normalize_crlf(&self) -> String

Newline replacement routine as described in step 1 of the multipart/form-data encoding algorithm and many steps of application/x-www-form-urlencoded. e.g. https://html.spec.whatwg.org/multipage/#convert-to-a-list-of-name-value-pairs

Replace every occurrence of U+000D (CR) not followed by U+000A (LF), and every occurrence of U+000A (LF) not preceded by U+000D (CR), in entry’s name, by a string consisting of a U+000D (CR) and U+000A (LF).

Trait Implementations

impl Clone for TracedDOMString

fn clone(&self) -> TracedDOMString

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TracedDOMString

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

Formats the value using the given formatter.

impl Default for TracedDOMString

fn default() -> TracedDOMString

Returns the “default value” for a type.

impl Display for TracedDOMString

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

Formats the value using the given formatter.

impl Extend<char> for TracedDOMString

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

Extends a collection with the contents of an iterator.

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.

impl From<String> for TracedDOMString

fn from(string: String) -> Self

Converts to this type from the input type.

impl From<TracedDOMString> for String

fn from(val: TracedDOMString) -> Self

Converts to this type from the input type.

impl From<TracedDOMString> for Vec<u8>

fn from(value: TracedDOMString) -> Self

Converts to this type from the input type.

impl Hash for TracedDOMString

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl MallocSizeOf for TracedDOMString

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl Ord for TracedDOMString

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<&str> for TracedDOMString

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

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

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 TracedDOMString

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

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

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<TracedDOMString> for String

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

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

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<TracedDOMString> for str

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

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

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 TracedDOMString

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

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

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 TracedDOMString

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

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

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 TracedDOMString

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

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

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

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

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

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

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

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

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

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

impl Traceable for TracedDOMString

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.

impl Zeroize for TracedDOMString

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for TracedDOMString