Struct DOMString

#[repr(transparent)]
pub struct DOMString(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 withh 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.)

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 string). You should assume that this conversion costs. You should assume that all the functions incur the conversion cost.

Tuple Fields

0: RefCell<DOMStringType>

Implementations

impl DOMString

pub fn new() -> DOMString

Creates a new DOMString.

pub fn from_js_string(cx: SafeJSContext, value: HandleValue<'_>) -> DOMString

Creates the string from js. If the string can be encoded in latin1, just take the reference to the JSString. Otherwise do the conversion to utf8 now.

pub fn from_string(s: String) -> DOMString

fn make_rust(&self)

Transforms the string into rust string if not yet a rust string.

fn debug_js(&self)

Debug the current state of the string without modifying it.

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

Returns the underlying rust string.

pub fn clear(&mut self)

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

This length (as rust spec) is in bytes not chars.

pub fn make_ascii_lowercase(&mut self)

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

pub fn strip_leading_and_trailing_ascii_whitespace(&mut self)

pub fn is_valid_floating_point_number_string(&self) -> bool

This is a dom spec

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

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

This is a domspec 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)

This is a dom spec

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 find(&self, c: char) -> Option<usize>

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 contains(&self, needle: &str) -> bool

pub fn to_ascii_lowercase(&self) -> String

pub fn contains_html_space_characters(&self) -> bool

pub fn as_bytes(&self) -> BytesView<'_>

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

Trait Implementations

impl Clone for DOMString

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DOMString

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

Formats the value using the given formatter.

impl Default for DOMString

fn default() -> Self

Returns the “default value” for a type.

impl Display for DOMString

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

Formats the value using the given formatter.

impl Extend<char> for DOMString

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<&DOMString> for LocalName

fn from(contents: &DOMString) -> LocalName

Converts to this type from the input type.

impl From<&str> for DOMString

fn from(contents: &str) -> DOMString

Converts to this type from the input type.

impl From<Cow<'_, str>> for DOMString

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

Converts to this type from the input type.

impl From<DOMString> for Atom

fn from(contents: DOMString) -> Atom

Converts to this type from the input type.

impl From<DOMString> for LocalName

fn from(contents: DOMString) -> LocalName

Converts to this type from the input type.

impl From<DOMString> for Namespace

fn from(contents: DOMString) -> Namespace

Converts to this type from the input type.

impl From<DOMString> for String

fn from(val: DOMString) -> Self

Converts to this type from the input type.

impl From<DOMString> for Vec<u8>

fn from(value: DOMString) -> Self

Converts to this type from the input type.

impl From<String> for DOMString

fn from(value: String) -> Self

Converts to this type from the input type.

impl FromJSValConvertible for DOMString

type Config = StringificationBehavior

Optional configurable behaviour switch; use () for no configuration.

unsafe fn from_jsval( cx: *mut JSContext, value: HandleValue<'_>, null_behavior: StringificationBehavior, ) -> Result<ConversionResult<DOMString>, ()>

Convert val to type Self. Optional configuration of type T can be passed as the option argument. If it returns Err(()), a JSAPI exception is pending. If it returns Ok(Failure(reason)), there is no pending JSAPI exception.

impl Hash for DOMString

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 DOMString

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 DOMString

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 DOMString

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

fn eq(&self, other: &DOMString) -> 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<DOMString> for str

fn eq(&self, other: &DOMString) -> 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 DOMString

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

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 DOMString

fn eq(&self, other: &DOMString) -> 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 DOMString

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 RecordKey for DOMString

fn to_utf16_vec(&self) -> Vec<u16>

unsafe fn from_id( cx: *mut JSContext, id: HandleId<'_>, ) -> Result<ConversionResult<Self>, ()>

Attempt to extract a key from a JS id.

impl ToJSValConvertible for DOMString

unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue<'_>)

Convert self to a JSVal. JSAPI failure causes a panic.

impl Traceable for DOMString

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

Trace self.

impl Eq for DOMString