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


/// `interface nsISAXErrorHandler : nsISupports`
///

/// ```text
/// /**
///  * Basic interface for SAX error handlers.
///  *
///  * If a SAX application needs to implement customized error
///  * handling, it must implement this interface and then register an
///  * instance with the XML reader.  The parser will then report all
///  * errors and warnings through this interface.
///  *
///  * WARNING: If an application does not register an ErrorHandler,
///  * XML parsing errors will go unreported. In order to detect validity
///  * errors, an ErrorHandler that does something with error() calls must
///  * be registered.
///  *
///  */
/// ```
///

// 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 nsISAXErrorHandler {
    vtable: *const nsISAXErrorHandlerVTable,

    /// 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 nsISAXErrorHandler.
unsafe impl XpCom for nsISAXErrorHandler {
    const IID: nsIID = nsID(0xe02b6693, 0x6cca, 0x11da,
        [0xbe, 0x43, 0x00, 0x14, 0x22, 0x10, 0x69, 0x90]);
}

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

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

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

    /* void error (in AString error); */
    pub Error: unsafe extern "system" fn (this: *const nsISAXErrorHandler, error: &::nsstring::nsAString) -> nsresult,

    /* void fatalError (in AString error); */
    pub FatalError: unsafe extern "system" fn (this: *const nsISAXErrorHandler, error: &::nsstring::nsAString) -> nsresult,

    /* void ignorableWarning (in AString error); */
    pub IgnorableWarning: unsafe extern "system" fn (this: *const nsISAXErrorHandler, error: &::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 nsISAXErrorHandler {

    /// ```text
    /// /**
    ///    * Receive notification of a recoverable error.
    ///    *
    ///    * This corresponds to the definition of "error" in section 1.2
    ///    * of the W3C XML 1.0 Recommendation. For example, a validating
    ///    * parser would use this callback to report the violation of a
    ///    * validity constraint. The default behaviour is to take no
    ///    * action.
    ///    *
    ///    * The SAX parser must continue to provide normal parsing events
    ///    * after invoking this method: it should still be possible for the
    ///    * application to process the document through to the end. If the
    ///    * application cannot do so, then the parser should report a fatal
    ///    * error even if the XML recommendation does not require it to do
    ///    * so.
    ///    *
    ///    * Filters may use this method to report other, non-XML errors as
    ///    * well.
    ///    *
    ///    * @param error The error message.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Receive notification of a non-recoverable error.
    ///    *
    ///    * There is an apparent contradiction between the documentation
    ///    * for this method and the documentation for
    ///    * ContentHandler.endDocument(). 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.
    ///    *
    ///    * This corresponds to the definition of "fatal error" in section
    ///    * 1.2 of the W3C XML 1.0 Recommendation. For example, a parser
    ///    * would use this callback to report the violation of a
    ///    * well-formedness constraint.
    ///    *
    ///    * The application must assume that the document is unusable
    ///    * after the parser has invoked this method, and should continue (if
        ///    * at all) only for the sake of collecting additional error
    ///    * messages: in fact, SAX parsers are free to stop reporting any
    ///    * other events once this method has been invoked.
    ///    *
    ///    * @param error The error message.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Receive notification of a warning.
    ///    *
    ///    * SAX parsers will use this method to report conditions that are
    ///    * not errors or fatal errors as defined by the XML
    ///    * recommendation. The default behaviour is to take no action.
    ///    *
    ///    * The SAX parser must continue to provide normal parsing events
    ///    * after invoking this method: it should still be possible for the
    ///    * application to process the document through to the end.
    ///    *
    ///    * Filters may use this method to report other, non-XML warnings
    ///    * as well.
    ///    *
    ///    * @param error The warning message.
    ///    */
    /// ```
    ///

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


}