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


/// `interface nsIRDFXMLSinkObserver : nsISupports`
///

/// ```text
/// /**
///  * An observer that is notified as progress is made on the load
///  * of an RDF/XML document in an <code>nsIRDFXMLSink</code>.
///  */
/// ```
///

// 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 nsIRDFXMLSinkObserver {
    vtable: *const nsIRDFXMLSinkObserverVTable,

    /// 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 nsIRDFXMLSinkObserver.
unsafe impl XpCom for nsIRDFXMLSinkObserver {
    const IID: nsIID = nsID(0xeb1a5d30, 0xab33, 0x11d2,
        [0x8e, 0xc6, 0x00, 0x80, 0x5f, 0x29, 0xf3, 0x70]);
}

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

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

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

    /* void onBeginLoad (in nsIRDFXMLSink aSink); */
    pub OnBeginLoad: unsafe extern "system" fn (this: *const nsIRDFXMLSinkObserver, aSink: *const nsIRDFXMLSink) -> nsresult,

    /* void onInterrupt (in nsIRDFXMLSink aSink); */
    pub OnInterrupt: unsafe extern "system" fn (this: *const nsIRDFXMLSinkObserver, aSink: *const nsIRDFXMLSink) -> nsresult,

    /* void onResume (in nsIRDFXMLSink aSink); */
    pub OnResume: unsafe extern "system" fn (this: *const nsIRDFXMLSinkObserver, aSink: *const nsIRDFXMLSink) -> nsresult,

    /* void onEndLoad (in nsIRDFXMLSink aSink); */
    pub OnEndLoad: unsafe extern "system" fn (this: *const nsIRDFXMLSinkObserver, aSink: *const nsIRDFXMLSink) -> nsresult,

    /* void onError (in nsIRDFXMLSink aSink, in nsresult aStatus, in wstring aErrorMsg); */
    pub OnError: unsafe extern "system" fn (this: *const nsIRDFXMLSinkObserver, aSink: *const nsIRDFXMLSink, aStatus: nsresult, aErrorMsg: *const libc::int16_t) -> 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 nsIRDFXMLSinkObserver {

    /// ```text
    /// /**
    ///      * Called when the load begins.
    ///      * @param aSink the RDF/XML sink on which the load is beginning.
    ///      */
    /// ```
    ///

    /// `void onBeginLoad (in nsIRDFXMLSink aSink);`
    #[inline]
    pub unsafe fn OnBeginLoad(&self, aSink: *const nsIRDFXMLSink) -> nsresult {
        ((*self.vtable).OnBeginLoad)(self, aSink)
    }


    /// ```text
    /// /**
    ///      * Called when the load is suspended (e.g., for network quantization).
    ///      * @param aSink the RDF/XML sink that is being interrupted.
    ///      */
    /// ```
    ///

    /// `void onInterrupt (in nsIRDFXMLSink aSink);`
    #[inline]
    pub unsafe fn OnInterrupt(&self, aSink: *const nsIRDFXMLSink) -> nsresult {
        ((*self.vtable).OnInterrupt)(self, aSink)
    }


    /// ```text
    /// /**
    ///      * Called when a suspended load is resuming.
    ///      * @param aSink the RDF/XML sink that is resuming.
    ///      */
    /// ```
    ///

    /// `void onResume (in nsIRDFXMLSink aSink);`
    #[inline]
    pub unsafe fn OnResume(&self, aSink: *const nsIRDFXMLSink) -> nsresult {
        ((*self.vtable).OnResume)(self, aSink)
    }


    /// ```text
    /// /**
    ///      * Called when an RDF/XML load completes successfully.
    ///      * @param aSink the RDF/XML sink that has finished loading.
    ///      */
    /// ```
    ///

    /// `void onEndLoad (in nsIRDFXMLSink aSink);`
    #[inline]
    pub unsafe fn OnEndLoad(&self, aSink: *const nsIRDFXMLSink) -> nsresult {
        ((*self.vtable).OnEndLoad)(self, aSink)
    }


    /// ```text
    /// /**
    ///      * Called when an error occurs during the load
    ///      * @param aSink the RDF/XML sink in which the error occurred
    ///      * @param aStatus the networking result code
    ///      * @param aErrorMsg an error message, if applicable
    ///      */
    /// ```
    ///

    /// `void onError (in nsIRDFXMLSink aSink, in nsresult aStatus, in wstring aErrorMsg);`
    #[inline]
    pub unsafe fn OnError(&self, aSink: *const nsIRDFXMLSink, aStatus: nsresult, aErrorMsg: *const libc::int16_t) -> nsresult {
        ((*self.vtable).OnError)(self, aSink, aStatus, aErrorMsg)
    }


}


/// `interface nsIRDFXMLSink : nsISupports`
///


// 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 nsIRDFXMLSink {
    vtable: *const nsIRDFXMLSinkVTable,

    /// 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 nsIRDFXMLSink.
unsafe impl XpCom for nsIRDFXMLSink {
    const IID: nsIID = nsID(0xeb1a5d31, 0xab33, 0x11d2,
        [0x8e, 0xc6, 0x00, 0x80, 0x5f, 0x29, 0xf3, 0x70]);
}

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

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

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

    /* attribute boolean readOnly; */
    pub GetReadOnly: unsafe extern "system" fn (this: *const nsIRDFXMLSink, aReadOnly: *mut bool) -> nsresult,

    /* attribute boolean readOnly; */
    pub SetReadOnly: unsafe extern "system" fn (this: *const nsIRDFXMLSink, aReadOnly: bool) -> nsresult,

    /* void beginLoad (); */
    pub BeginLoad: unsafe extern "system" fn (this: *const nsIRDFXMLSink) -> nsresult,

    /* void interrupt (); */
    pub Interrupt: unsafe extern "system" fn (this: *const nsIRDFXMLSink) -> nsresult,

    /* void resume (); */
    pub Resume: unsafe extern "system" fn (this: *const nsIRDFXMLSink) -> nsresult,

    /* void endLoad (); */
    pub EndLoad: unsafe extern "system" fn (this: *const nsIRDFXMLSink) -> nsresult,

    /* [noscript] void addNameSpace (in nsAtomPtr aPrefix, [const] in nsStringRef aURI); */
    /// Unable to generate binding because `native type nsAtom is unsupported`
    pub AddNameSpace: *const ::libc::c_void,

    /* void addXMLSinkObserver (in nsIRDFXMLSinkObserver aObserver); */
    pub AddXMLSinkObserver: unsafe extern "system" fn (this: *const nsIRDFXMLSink, aObserver: *const nsIRDFXMLSinkObserver) -> nsresult,

    /* void removeXMLSinkObserver (in nsIRDFXMLSinkObserver aObserver); */
    pub RemoveXMLSinkObserver: unsafe extern "system" fn (this: *const nsIRDFXMLSink, aObserver: *const nsIRDFXMLSinkObserver) -> 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 nsIRDFXMLSink {

    /// ```text
    /// /**
    ///  * A "sink" that receives and processes RDF/XML. This interface is used
    ///  * by the RDF/XML parser.
    ///  */
    /// /**
    ///      * Set to <code>true</code> if the sink is read-only and cannot
    ///      * be modified
    ///      */
    /// ```
    ///

    /// `attribute boolean readOnly;`
    #[inline]
    pub unsafe fn GetReadOnly(&self, aReadOnly: *mut bool) -> nsresult {
        ((*self.vtable).GetReadOnly)(self, aReadOnly)
    }


    /// ```text
    /// /**
    ///  * A "sink" that receives and processes RDF/XML. This interface is used
    ///  * by the RDF/XML parser.
    ///  */
    /// /**
    ///      * Set to <code>true</code> if the sink is read-only and cannot
    ///      * be modified
    ///      */
    /// ```
    ///

    /// `attribute boolean readOnly;`
    #[inline]
    pub unsafe fn SetReadOnly(&self, aReadOnly: bool) -> nsresult {
        ((*self.vtable).SetReadOnly)(self, aReadOnly)
    }


    /// ```text
    /// /**
    ///      * Initiate the RDF/XML load.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Suspend the RDF/XML load.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Resume the RDF/XML load.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Complete the RDF/XML load.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Add namespace information to the RDF/XML sink.
    ///      * @param aPrefix the namespace prefix
    ///      * @param aURI the namespace URI
    ///      */
    /// ```
    ///

    /// `[noscript] void addNameSpace (in nsAtomPtr aPrefix, [const] in nsStringRef aURI);`
    const _AddNameSpace: () = ();

    /// ```text
    /// /**
    ///      * Add an observer that will be notified as the RDF/XML load
    ///      * progresses.
    ///      * <p>
    ///      *
    ///      * Note that the sink will acquire a strong reference to the
    ///      * observer, so care should be taken to avoid cyclical references
    ///      * that cannot be released (i.e., if the observer holds a
        ///      * reference to the sink, it should be sure that it eventually
        ///      * clears the reference).
    ///      *
    ///      * @param aObserver the observer to add to the sink's set of
    ///      * load observers.
    ///      */
    /// ```
    ///

    /// `void addXMLSinkObserver (in nsIRDFXMLSinkObserver aObserver);`
    #[inline]
    pub unsafe fn AddXMLSinkObserver(&self, aObserver: *const nsIRDFXMLSinkObserver) -> nsresult {
        ((*self.vtable).AddXMLSinkObserver)(self, aObserver)
    }


    /// ```text
    /// /**
    ///      * Remove an observer from the sink's set of observers.
    ///      * @param aObserver the observer to remove.
    ///      */
    /// ```
    ///

    /// `void removeXMLSinkObserver (in nsIRDFXMLSinkObserver aObserver);`
    #[inline]
    pub unsafe fn RemoveXMLSinkObserver(&self, aObserver: *const nsIRDFXMLSinkObserver) -> nsresult {
        ((*self.vtable).RemoveXMLSinkObserver)(self, aObserver)
    }


}