Struct xpcom::interfaces::nsIDOMParser

#[repr(C)]
pub struct nsIDOMParser { /* fields omitted */ }

interface nsIDOMParser : nsISupports

/**
 * The nsIDOMParser interface is a non-SAX interface that can be used
 * to parse a string or byte stream containing XML or HTML content
 * to a DOM document. Parsing is always synchronous - a document is always
 * returned from the parsing methods. This is as opposed to loading and
 * parsing with the XMLHttpRequest interface, which can be used for
 * asynchronous (callback-based) loading.
 */

Methods

impl nsIDOMParser

pub fn coerce<T: nsIDOMParserCoerce>(&self) -> &T

Cast this nsIDOMParser to one of its base interfaces.

impl nsIDOMParser

pub unsafe fn ParseFromString(
    &self,
    str: *const int16_t,
    contentType: *const c_char,
    _retval: *mut *const nsIDOMDocument
) -> nsresult

/**
   * The string passed in is parsed into a DOM document.
   *
   * @param str The UTF16 string to be parsed
   * @param contentType The content type of the string (see parseFromStream)
   * @returns The DOM document created as a result of parsing the
   *          string
   */

nsIDOMDocument parseFromString (in wstring str, in string contentType);

pub unsafe fn ParseFromBuffer(
    &self,
    buf: *const uint8_t,
    bufLen: uint32_t,
    contentType: *const c_char,
    _retval: *mut *const nsIDOMDocument
) -> nsresult

/**
   * The buffer is parsed into a DOM document.
   * The charset is determined from the xml entity decl.
   *
   * @param buf The octet array data to be parsed
   * @param bufLen Length (in bytes) of the data
   * @param contentType The content type of the data (see parseFromStream)
   * @returns The DOM document created as a result of parsing the
   *          string
   */

nsIDOMDocument parseFromBuffer ([array, size_is (bufLen), const] in octet buf, in uint32_t bufLen, in string contentType);

pub unsafe fn ParseFromStream(
    &self,
    stream: *const nsIInputStream,
    charset: *const c_char,
    contentLength: int32_t,
    contentType: *const c_char,
    _retval: *mut *const nsIDOMDocument
) -> nsresult

/**
   * The byte stream passed in is parsed into a DOM document.
   *
   * Not accessible from web content.
   *
   * @param stream The byte stream whose contents are parsed
   * @param charset The character set that was used to encode the byte
   *                stream. NULL if not specified.
   * @param contentLength The number of bytes in the input stream.
   * @param contentType The content type of the string - either text/xml,
   *                    application/xml, or application/xhtml+xml.
   *                    Must not be NULL.
   * @returns The DOM document created as a result of parsing the
   *          stream
   */

nsIDOMDocument parseFromStream (in nsIInputStream stream, in string charset, in long contentLength, in string contentType);

pub unsafe fn Init(
    &self,
    principal: *const nsIPrincipal,
    documentURI: *const nsIURI,
    baseURI: *const nsIURI,
    scriptObject: *const nsIGlobalObject
) -> nsresult

/**
   * Initialize the principal and document and base URIs that the parser should
   * use for documents it creates.  If this is not called, then a null
   * principal and its URI will be used.  When creating a DOMParser via the JS
   * constructor, this will be called automatically.  This method may only be
   * called once.  If this method fails, all following parse attempts will
   * fail.
   *
   * @param principal The principal to use for documents we create.
   *                  If this is null, a codebase principal will be created
   *                  based on documentURI; in that case the documentURI must
   *                  be non-null.
   * @param documentURI The documentURI to use for the documents we create.
   *                    If null, the principal's URI will be used;
   *                    in that case, the principal must be non-null and its
   *                    URI must be non-null.
   * @param baseURI The baseURI to use for the documents we create.
   *                If null, the documentURI will be used.
   * @param scriptObject The object from which the context for event handling
   *                     can be got.
   */

[noscript] void init (in nsIPrincipal principal, in nsIURI documentURI, in nsIURI baseURI, in nsIGlobalObject scriptObject);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIDOMParser

const IID: nsIID

IID: nsIID = nsID(1891196942, 34338, 19603, [154, 216, 34, 194, 128, 88, 220, 68])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIDOMParser

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIDOMParser

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.