//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsISAXContentHandler.idl
//


/// `interface nsISAXContentHandler : nsISupports`
///

/// ```text
/// /**
///  * Receive notification of the logical content of a document.
///  *
///  * This is the main interface that most SAX applications implement: if
///  * the application needs to be informed of basic parsing events, it
///  * implements this interface and registers an instance with the SAX
///  * parser.  The parser uses the instance to report basic
///  * document-related events like the start and end of elements and
///  * character data.
///  *
///  * The order of events in this interface is very important, and
///  * mirrors the order of information in the document itself.  For
///  * example, all of an element's content (character data, processing
    ///  * instructions, and/or subelements) will appear, in order, between
///  * the startElement event and the corresponding endElement event.
///  */
/// ```
///

// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsISAXContentHandler {
    vtable: *const nsISAXContentHandlerVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsISAXContentHandler.
unsafe impl XpCom for nsISAXContentHandler {
    const IID: nsIID = nsID(0x2a99c757, 0xdfee, 0x4806,
        [0xbf, 0xf3, 0xf7, 0x21, 0x44, 0x04, 0x12, 0xe0]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsISAXContentHandler {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsISAXContentHandler.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsISAXContentHandlerCoerce {
    /// Cheaply cast a value of this type from a `nsISAXContentHandler`.
    fn coerce_from(v: &nsISAXContentHandler) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsISAXContentHandlerCoerce for nsISAXContentHandler {
    #[inline]
    fn coerce_from(v: &nsISAXContentHandler) -> &Self {
        v
    }
}

impl nsISAXContentHandler {
    /// Cast this `nsISAXContentHandler` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISAXContentHandlerCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsISAXContentHandler {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsISAXContentHandlerCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISAXContentHandler) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsISAXContentHandler
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsISAXContentHandlerVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* void startDocument (); */
    pub StartDocument: unsafe extern "system" fn (this: *const nsISAXContentHandler) -> nsresult,

    /* void endDocument (); */
    pub EndDocument: unsafe extern "system" fn (this: *const nsISAXContentHandler) -> nsresult,

    /* void startElement (in AString uri, in AString localName, in AString qName, in nsISAXAttributes attributes); */
    pub StartElement: unsafe extern "system" fn (this: *const nsISAXContentHandler, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, qName: &::nsstring::nsAString, attributes: *const nsISAXAttributes) -> nsresult,

    /* void endElement (in AString uri, in AString localName, in AString qName); */
    pub EndElement: unsafe extern "system" fn (this: *const nsISAXContentHandler, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, qName: &::nsstring::nsAString) -> nsresult,

    /* void characters (in AString value); */
    pub Characters: unsafe extern "system" fn (this: *const nsISAXContentHandler, value: &::nsstring::nsAString) -> nsresult,

    /* void processingInstruction (in AString target, in AString data); */
    pub ProcessingInstruction: unsafe extern "system" fn (this: *const nsISAXContentHandler, target: &::nsstring::nsAString, data: &::nsstring::nsAString) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsISAXContentHandler {

    /// ```text
    /// /**
    ///    * Receive notification of the beginning of a document.
    ///    *
    ///    * The SAX parser will invoke this method only once, before any
    ///    * other event callbacks.
    ///    */
    /// ```
    ///

    /// `void startDocument ();`
    #[inline]
    pub unsafe fn StartDocument(&self, ) -> nsresult {
        ((*self.vtable).StartDocument)(self, )
    }


    /// ```text
    /// /**
    ///    * Receive notification of the end of a document.
    ///    *
    ///    * There is an apparent contradiction between the documentation for
    ///    * this method and the documentation for ErrorHandler.fatalError().
    ///    * Until this ambiguity is resolved in a future major release,
    ///    * clients should make no assumptions about whether endDocument()
    ///    * will or will not be invoked when the parser has reported a
    ///    * fatalError() or thrown an exception.
    ///    *
    ///    * The SAX parser will invoke this method only once, and it will be
    ///    * the last method invoked during the parse.  The parser shall not
    ///    * invoke this method until it has either abandoned parsing (because
        ///    * of an unrecoverable error) or reached the end of input.
    ///    */
    /// ```
    ///

    /// `void endDocument ();`
    #[inline]
    pub unsafe fn EndDocument(&self, ) -> nsresult {
        ((*self.vtable).EndDocument)(self, )
    }


    /// ```text
    /// /**
    ///    * Receive notification of the beginning of an element.
    ///    *
    ///    * The Parser will invoke this method at the beginning of every
    ///    * element in the XML document; there will be a corresponding
    ///    * endElement event for every startElement event (even when the
        ///    * element is empty). All of the element's content will be reported,
    ///    * in order, before the corresponding endElement event.
    ///    *
    ///    * This event allows up to three name components for each element:
    ///    *
    ///    * 1.) the Namespace URI;
///    * 2.) the local name; and
///    * 3.) the qualified (prefixed) name.
///    *
///    * Any or all of these may be provided, depending on the values of
///    * the http://xml.org/sax/features/namespaces and the
///    * http://xml.org/sax/features/namespace-prefixes properties:
///    *
///    * The Namespace URI and local name are required when the namespaces
///    * property is true (the default), and are optional when the
///    * namespaces property is false (if one is specified, both must be);
///    *
///    * The qualified name is required when the namespace-prefixes
///    * property is true, and is optional when the namespace-prefixes
///    * property is false (the default).
///    *
///    * Note that the attribute list provided will contain only
///    * attributes with explicit values (specified or defaulted):
///    * #IMPLIED attributes will be omitted.  The attribute list will
///    * contain attributes used for Namespace declarations (xmlns*
///    * attributes) only if the
///    * http://xml.org/sax/features/namespace-prefixes property is true
///    * (it is false by default, and support for a true value is
///    * optional).
///    *
///    * @param uri the Namespace URI, or the empty string if the
///    *        element has no Namespace URI or if Namespace
///    *        processing is not being performed
///    * @param localName the local name (without prefix), or the
///    *        empty string if Namespace processing is not being
///    *        performed
///    * @param qName the qualified name (with prefix), or the
///    *        empty string if qualified names are not available
///    * @param atts the attributes attached to the element.  If
///    *        there are no attributes, it shall be an empty
///    *        SAXAttributes object.  The value of this object after
///    *        startElement returns is undefined
///    */
/// ```
///

/// `void startElement (in AString uri, in AString localName, in AString qName, in nsISAXAttributes attributes);`
#[inline]
pub unsafe fn StartElement(&self, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, qName: &::nsstring::nsAString, attributes: *const nsISAXAttributes) -> nsresult {
((*self.vtable).StartElement)(self, uri, localName, qName, attributes)
}


/// ```text
/// /**
///    * Receive notification of the end of an element.
///    *
///    * The SAX parser will invoke this method at the end of every
///    * element in the XML document; there will be a corresponding
///    * startElement event for every endElement event (even when the
///    * element is empty).
///    *
///    * For information on the names, see startElement.
///    *
///    * @param uri the Namespace URI, or the empty string if the
///    *        element has no Namespace URI or if Namespace
///    *        processing is not being performed
///    * @param localName the local name (without prefix), or the
///    *        empty string if Namespace processing is not being
///    *        performed
///    * @param qName the qualified XML name (with prefix), or the
///    *        empty string if qualified names are not available
///    */
/// ```
///

/// `void endElement (in AString uri, in AString localName, in AString qName);`
#[inline]
pub unsafe fn EndElement(&self, uri: &::nsstring::nsAString, localName: &::nsstring::nsAString, qName: &::nsstring::nsAString) -> nsresult {
((*self.vtable).EndElement)(self, uri, localName, qName)
}


/// ```text
/// /**
///    * Receive notification of character data.
///    *
///    * The Parser will call this method to report each chunk of
///    * character data.  SAX parsers may return all contiguous character
///    * data in a single chunk, or they may split it into several chunks;
///    * however, all of the characters in any single event must come from
///    * the same external entity so that the Locator provides useful
///    * information.
///    *
///    * Note that some parsers would report whitespace in element
///    * content using the ignorableWhitespace method rather than this one
///    * (validating parsers must do so). But this interface no longer has an
///    * ignorableWhitespace method, so in that case such whitespace is not
///    * reported at all.
///    *
///    * @param value the characters from the XML document
///    */
/// ```
///

/// `void characters (in AString value);`
#[inline]
pub unsafe fn Characters(&self, value: &::nsstring::nsAString) -> nsresult {
((*self.vtable).Characters)(self, value)
}


/// ```text
/// /**
///    * Receive notification of a processing instruction.
///    *
///    * The Parser will invoke this method once for each processing
///    * instruction found: note that processing instructions may occur
///    * before or after the main document element.
///    *
///    * A SAX parser must never report an XML declaration (XML 1.0,
///    * section 2.8) or a text declaration (XML 1.0, section 4.3.1) using
///    * this method.
///    *
///    * @param target the processing instruction target
///    * @param data the processing instruction data, or null if
///    *        none was supplied.  The data does not include any
///    *        whitespace separating it from the target
///    */
/// ```
///

/// `void processingInstruction (in AString target, in AString data);`
#[inline]
pub unsafe fn ProcessingInstruction(&self, target: &::nsstring::nsAString, data: &::nsstring::nsAString) -> nsresult {
((*self.vtable).ProcessingInstruction)(self, target, data)
}


}