Struct xpcom::interfaces::nsIExpatSink

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

interface nsIExpatSink : nsISupports

/**
 * This interface should be implemented by any content sink that wants
 * to get output from expat and do something with it; in other words,
 * by any sink that handles some sort of XML dialect.
 */

Methods

impl nsIExpatSink

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

Cast this nsIExpatSink to one of its base interfaces.

impl nsIExpatSink

pub unsafe fn HandleStartElement(
    &self,
    aName: *const int16_t,
    aAtts: *mut *const int16_t,
    aAttsCount: uint32_t,
    aLineNumber: uint32_t
) -> nsresult

/**
   * Called to handle the opening tag of an element.
   * @param aName the fully qualified tagname of the element
   * @param aAtts the array of attribute names and values.  There are
   *        aAttsCount/2 names and aAttsCount/2 values, so the total number of
   *        elements in the array is aAttsCount.  The names and values
   *        alternate.  Thus, if we number attributes starting with 0,
   *        aAtts[2*k] is the name of the k-th attribute and aAtts[2*k+1] is
   *        the value of that attribute  Both explicitly specified attributes
   *        and attributes that are defined to have default values in a DTD are
   *        present in aAtts.
   * @param aAttsCount the number of elements in aAtts.
   * @param aLineNumber the line number of the start tag in the data stream.
   */

void HandleStartElement (in wstring aName, [array, size_is (aAttsCount)] in wstring aAtts, in unsigned long aAttsCount, in unsigned long aLineNumber);

pub unsafe fn HandleEndElement(&self, aName: *const int16_t) -> nsresult

/**
   * Called to handle the closing tag of an element.
   * @param aName the fully qualified tagname of the element
   */

void HandleEndElement (in wstring aName);

pub unsafe fn HandleComment(&self, aCommentText: *const int16_t) -> nsresult

/**
   * Called to handle a comment
   * @param aCommentText the text of the comment (not including the
   *        "<!--" and "-->")
   */

void HandleComment (in wstring aCommentText);

pub unsafe fn HandleCDataSection(
    &self,
    aData: *const int16_t,
    aLength: uint32_t
) -> nsresult

/**
   * Called to handle a CDATA section
   * @param aData the text in the CDATA section.  This is null-terminated.
   * @param aLength the length of the aData string
   */

void HandleCDataSection ([size_is (aLength)] in wstring aData, in unsigned long aLength);

pub unsafe fn HandleDoctypeDecl(
    &self,
    aSubset: &nsAString,
    aName: &nsAString,
    aSystemId: &nsAString,
    aPublicId: &nsAString,
    aCatalogData: *const nsISupports
) -> nsresult

/**
   * Called to handle the doctype declaration
   */

void HandleDoctypeDecl (in AString aSubset, in AString aName, in AString aSystemId, in AString aPublicId, in nsISupports aCatalogData);

pub unsafe fn HandleCharacterData(
    &self,
    aData: *const int16_t,
    aLength: uint32_t
) -> nsresult

/**
   * Called to handle character data.  Note that this does NOT get
   * called for the contents of CDATA sections.
   * @param aData the data to handle.  aData is NOT NULL-TERMINATED.
   * @param aLength the length of the aData string
   */

void HandleCharacterData ([size_is (aLength)] in wstring aData, in unsigned long aLength);

pub unsafe fn HandleProcessingInstruction(
    &self,
    aTarget: *const int16_t,
    aData: *const int16_t
) -> nsresult

/**
   * Called to handle a processing instruction
   * @param aTarget the PI target (e.g. xml-stylesheet)
   * @param aData all the rest of the data in the PI
   */

void HandleProcessingInstruction (in wstring aTarget, in wstring aData);

pub unsafe fn HandleXMLDeclaration(
    &self,
    aVersion: *const int16_t,
    aEncoding: *const int16_t,
    aStandalone: int32_t
) -> nsresult

/**
   * Handle the XML Declaration.
   *
   * @param aVersion    The version string, can be null if not specified.
   * @param aEncoding   The encoding string, can be null if not specified.
   * @param aStandalone -1, 0, or 1 indicating respectively that there was no
   *                    standalone parameter in the declaration, that it was
   *                    given as no, or that it was given as yes.
   */

void HandleXMLDeclaration (in wstring aVersion, in wstring aEncoding, in long aStandalone);

pub unsafe fn ReportError(
    &self,
    aErrorText: *const int16_t,
    aSourceText: *const int16_t,
    aError: *const nsIScriptError,
    _retval: *mut bool
) -> nsresult

/**
   * Ask the content sink if the expat driver should log an error to the console.
   *
   * @param aErrorText  Error message to pass to content sink.
   * @param aSourceText Source text of the document we're parsing.
   * @param aError      Script error object with line number & column number
   *
   * @retval True if the expat driver should report the error.
   */

boolean ReportError (in wstring aErrorText, in wstring aSourceText, in nsIScriptError aError);

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 nsIExpatSink

const IID: nsIID

IID: nsIID = nsID(32932271, 3874, 18213, [169, 20, 13, 57, 97, 20, 218, 240])

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 nsIExpatSink

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIExpatSink

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.