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


/// `interface nsIDOMOfflineResourceList : 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 nsIDOMOfflineResourceList {
    vtable: *const nsIDOMOfflineResourceListVTable,

    /// 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 nsIDOMOfflineResourceList.
unsafe impl XpCom for nsIDOMOfflineResourceList {
    const IID: nsIID = nsID(0x6044702d, 0xe4a9, 0x420c,
        [0xb7, 0x11, 0x55, 0x8b, 0x7d, 0x6a, 0x3b, 0x9f]);
}

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

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

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

    /* readonly attribute nsISupports mozItems; */
    pub GetMozItems: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList, aMozItems: *mut *const nsISupports) -> nsresult,

    /* boolean mozHasItem (in DOMString uri); */
    pub MozHasItem: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList, uri: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* readonly attribute unsigned long mozLength; */
    pub GetMozLength: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList, aMozLength: *mut libc::uint32_t) -> nsresult,

    /* DOMString mozItem (in unsigned long index); */
    pub MozItem: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void mozAdd (in DOMString uri); */
    pub MozAdd: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList, uri: &::nsstring::nsAString) -> nsresult,

    /* void mozRemove (in DOMString uri); */
    pub MozRemove: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList, uri: &::nsstring::nsAString) -> nsresult,

    /* readonly attribute unsigned short status; */
    pub GetStatus: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList, aStatus: *mut libc::uint16_t) -> nsresult,

    /* void update (); */
    pub Update: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList) -> nsresult,

    /* void swapCache (); */
    pub SwapCache: unsafe extern "system" fn (this: *const nsIDOMOfflineResourceList) -> 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 nsIDOMOfflineResourceList {
    /// ```text
    /// /**
    ///    * State of the application cache this object is associated with.
    ///    */
    /// ```
    ///

    pub const UNCACHED: i64 = 0;


    pub const IDLE: i64 = 1;


    pub const CHECKING: i64 = 2;


    pub const DOWNLOADING: i64 = 3;


    pub const UPDATEREADY: i64 = 4;


    pub const OBSOLETE: i64 = 5;

    /// ```text
    /// /**
    ///    * Get the list of dynamically-managed entries.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsISupports mozItems;`
    #[inline]
    pub unsafe fn GetMozItems(&self, aMozItems: *mut *const nsISupports) -> nsresult {
        ((*self.vtable).GetMozItems)(self, aMozItems)
    }


    /// ```text
    /// /**
    ///    * Check that an entry exists in the list of dynamically-managed entries.
    ///    *
    ///    * @param uri
    ///    *        The resource to check.
    ///    */
    /// ```
    ///

    /// `boolean mozHasItem (in DOMString uri);`
    #[inline]
    pub unsafe fn MozHasItem(&self, uri: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).MozHasItem)(self, uri, _retval)
    }


    /// ```text
    /// /**
    ///    * Get the number of dynamically-managed entries.
    ///    * @status DEPRECATED
    ///    *         Clients should use the "items" attribute.
    ///    */
    /// ```
    ///

    /// `readonly attribute unsigned long mozLength;`
    #[inline]
    pub unsafe fn GetMozLength(&self, aMozLength: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetMozLength)(self, aMozLength)
    }


    /// ```text
    /// /**
    ///    * Get the URI of a dynamically-managed entry.
    ///    * @status DEPRECATED
    ///    *         Clients should use the "items" attribute.
    ///    */
    /// ```
    ///

    /// `DOMString mozItem (in unsigned long index);`
    #[inline]
    pub unsafe fn MozItem(&self, index: libc::uint32_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).MozItem)(self, index, _retval)
    }


    /// ```text
    /// /**
    ///    * Add an item to the list of dynamically-managed entries.  The resource
    ///    * will be fetched into the application cache.
    ///    *
    ///    * @param uri
    ///    *        The resource to add.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Remove an item from the list of dynamically-managed entries.  If this
    ///    * was the last reference to a URI in the application cache, the cache
    ///    * entry will be removed.
    ///    *
    ///    * @param uri
    ///    *        The resource to remove.
    ///    */
    /// ```
    ///

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



    /// `readonly attribute unsigned short status;`
    #[inline]
    pub unsafe fn GetStatus(&self, aStatus: *mut libc::uint16_t) -> nsresult {
        ((*self.vtable).GetStatus)(self, aStatus)
    }


    /// ```text
    /// /**
    ///    * Begin the application update process on the associated application cache.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Swap in the newest version of the application cache, or disassociate
    ///    * from the cache if the cache group is obsolete.
    ///    */
    /// ```
    ///

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


}