Struct DOMString 

pub struct DOMString(RootedTraceableBox<TracedDOMString>);

Tuple Fields

0: RootedTraceableBox<TracedDOMString>

Implementations

impl DOMString

pub fn new() -> DOMString

Creates a new DOMString.

pub fn from_js_string( cx: &mut JSContext, value: HandleValue<'_>, ) -> Result<DOMString, DOMStringErrorType>

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. https://webidl.spec.whatwg.org/#js-DOMString

pub unsafe fn from_raw_js_string( cx: &JSContext, string_ptr: *mut JSString, ) -> Result<DOMString, DOMStringErrorType>

Takes a raw *mut JSString and creates a DOMString out of it. Prefer DOMString::from_js_string if you have a HandleValue. Seee DOMString::from_js_string for more detail.

Safety

*mut JSString needs to point to a valid JSString.

pub fn from_static(s: &'static str) -> DOMString

Creates a DOMString from a &'static str reference. More efficient than allocating the string.

pub fn traced(self) -> TracedDOMString

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

Methods from Deref<Target = TracedDOMString>

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 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 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() -> DOMString

Returns the “default value” for a type.

impl Deref for DOMString

type Target = TracedDOMString

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for DOMString

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Display for DOMString

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

Formats the value using the given formatter.

impl Eq for DOMString

impl From<&DOMString> for LocalName

fn from(dom_string: &DOMString) -> LocalName

Converts to this type from the input type.

impl From<&str> for DOMString

If you have a static str use the provided DOMString::from_static.

fn from(string: &str) -> Self

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 LocalName

fn from(dom_string: DOMString) -> LocalName

Converts to this type from the input type.

impl From<DOMString> for Namespace

fn from(dom_string: DOMString) -> Namespace

Converts to this type from the input type.

impl From<DOMString> for Atom

fn from(dom_string: DOMString) -> Atom

Converts to this type from the input type.

impl From<DOMString> for String

fn from(value: 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(string: String) -> Self

Converts to this type from the input type.

impl From<USVString> for DOMString

fn from(value: USVString) -> Self

Converts to this type from the input type.

impl FromJSValConvertible for DOMString

type Config = StringificationBehavior

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

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

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<&str> for DOMString

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<DOMString> for String

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<DOMString> for str

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<String> for DOMString

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<str> for DOMString

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

Equality operator ==.

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

Inequality operator !=.

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>

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

Attempt to extract a key from a JS id.

impl ToJSValConvertible for DOMString

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

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.