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


/// `interface nsIDOMParser : nsISupports`
///

/// ```text
/// /**
///  * 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.
///  */
/// ```
///

// 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 nsIDOMParser {
    vtable: *const nsIDOMParserVTable,

    /// 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 nsIDOMParser.
unsafe impl XpCom for nsIDOMParser {
    const IID: nsIID = nsID(0x70b9600e, 0x8622, 0x4c93,
        [0x9a, 0xd8, 0x22, 0xc2, 0x80, 0x58, 0xdc, 0x44]);
}

// 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 nsIDOMParser {
    #[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 nsIDOMParser.
// 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 nsIDOMParserCoerce {
    /// Cheaply cast a value of this type from a `nsIDOMParser`.
    fn coerce_from(v: &nsIDOMParser) -> &Self;
}

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

impl nsIDOMParser {
    /// Cast this `nsIDOMParser` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIDOMParserCoerce>(&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 nsIDOMParser {
    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> nsIDOMParserCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIDOMParser) -> &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 nsIDOMParser
// 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 nsIDOMParserVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* nsIDOMDocument parseFromString (in wstring str, in string contentType); */
    pub ParseFromString: unsafe extern "system" fn (this: *const nsIDOMParser, str: *const libc::int16_t, contentType: *const libc::c_char, _retval: *mut *const nsIDOMDocument) -> nsresult,

    /* nsIDOMDocument parseFromBuffer ([array, size_is (bufLen), const] in octet buf, in uint32_t bufLen, in string contentType); */
    pub ParseFromBuffer: unsafe extern "system" fn (this: *const nsIDOMParser, buf: *const libc::uint8_t, bufLen: uint32_t, contentType: *const libc::c_char, _retval: *mut *const nsIDOMDocument) -> nsresult,

    /* nsIDOMDocument parseFromStream (in nsIInputStream stream, in string charset, in long contentLength, in string contentType); */
    pub ParseFromStream: unsafe extern "system" fn (this: *const nsIDOMParser, stream: *const nsIInputStream, charset: *const libc::c_char, contentLength: libc::int32_t, contentType: *const libc::c_char, _retval: *mut *const nsIDOMDocument) -> nsresult,

    /* [noscript] void init (in nsIPrincipal principal, in nsIURI documentURI, in nsIURI baseURI, in nsIGlobalObject scriptObject); */
    pub Init: unsafe extern "system" fn (this: *const nsIDOMParser, principal: *const nsIPrincipal, documentURI: *const nsIURI, baseURI: *const nsIURI, scriptObject: *const nsIGlobalObject) -> 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 nsIDOMParser {

    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn ParseFromString(&self, str: *const libc::int16_t, contentType: *const libc::c_char, _retval: *mut *const nsIDOMDocument) -> nsresult {
        ((*self.vtable).ParseFromString)(self, str, contentType, _retval)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn ParseFromBuffer(&self, buf: *const libc::uint8_t, bufLen: uint32_t, contentType: *const libc::c_char, _retval: *mut *const nsIDOMDocument) -> nsresult {
        ((*self.vtable).ParseFromBuffer)(self, buf, bufLen, contentType, _retval)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn ParseFromStream(&self, stream: *const nsIInputStream, charset: *const libc::c_char, contentLength: libc::int32_t, contentType: *const libc::c_char, _retval: *mut *const nsIDOMDocument) -> nsresult {
        ((*self.vtable).ParseFromStream)(self, stream, charset, contentLength, contentType, _retval)
    }


    /// ```text
    /// /**
    ///    * 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);`
    #[inline]
    pub unsafe fn Init(&self, principal: *const nsIPrincipal, documentURI: *const nsIURI, baseURI: *const nsIURI, scriptObject: *const nsIGlobalObject) -> nsresult {
        ((*self.vtable).Init)(self, principal, documentURI, baseURI, scriptObject)
    }


}