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


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

    /// 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 nsIQuotaManagerService.
unsafe impl XpCom for nsIQuotaManagerService {
    const IID: nsIID = nsID(0x1b3d0a38, 0x8151, 0x4cf9,
        [0x89, 0xfa, 0x4f, 0x92, 0xc2, 0xef, 0x0e, 0x7e]);
}

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

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

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

    /* [must_use] nsIQuotaRequest init (); */
    pub Init: unsafe extern "system" fn (this: *const nsIQuotaManagerService, _retval: *mut *const nsIQuotaRequest) -> nsresult,

    /* [must_use] nsIQuotaRequest initStoragesForPrincipal (in nsIPrincipal aPrincipal, in ACString aPersistenceType); */
    pub InitStoragesForPrincipal: unsafe extern "system" fn (this: *const nsIQuotaManagerService, aPrincipal: *const nsIPrincipal, aPersistenceType: &::nsstring::nsACString, _retval: *mut *const nsIQuotaRequest) -> nsresult,

    /* [must_use] nsIQuotaUsageRequest getUsage (in nsIQuotaUsageCallback aCallback, [optional] in boolean aGetAll); */
    pub GetUsage: unsafe extern "system" fn (this: *const nsIQuotaManagerService, aCallback: *const nsIQuotaUsageCallback, aGetAll: bool, _retval: *mut *const nsIQuotaUsageRequest) -> nsresult,

    /* [must_use] nsIQuotaUsageRequest getUsageForPrincipal (in nsIPrincipal aPrincipal, in nsIQuotaUsageCallback aCallback, [optional] in boolean aGetGroupUsage); */
    pub GetUsageForPrincipal: unsafe extern "system" fn (this: *const nsIQuotaManagerService, aPrincipal: *const nsIPrincipal, aCallback: *const nsIQuotaUsageCallback, aGetGroupUsage: bool, _retval: *mut *const nsIQuotaUsageRequest) -> nsresult,

    /* [must_use] nsIQuotaRequest clear (); */
    pub Clear: unsafe extern "system" fn (this: *const nsIQuotaManagerService, _retval: *mut *const nsIQuotaRequest) -> nsresult,

    /* [must_use] nsIQuotaRequest clearStoragesForPrincipal (in nsIPrincipal aPrincipal, [optional] in ACString aPersistenceType, [optional] in boolean aClearAll); */
    pub ClearStoragesForPrincipal: unsafe extern "system" fn (this: *const nsIQuotaManagerService, aPrincipal: *const nsIPrincipal, aPersistenceType: &::nsstring::nsACString, aClearAll: bool, _retval: *mut *const nsIQuotaRequest) -> nsresult,

    /* [must_use] nsIQuotaRequest reset (); */
    pub Reset: unsafe extern "system" fn (this: *const nsIQuotaManagerService, _retval: *mut *const nsIQuotaRequest) -> nsresult,

    /* [must_use] nsIQuotaRequest persisted (in nsIPrincipal aPrincipal); */
    pub Persisted: unsafe extern "system" fn (this: *const nsIQuotaManagerService, aPrincipal: *const nsIPrincipal, _retval: *mut *const nsIQuotaRequest) -> nsresult,

    /* [must_use] nsIQuotaRequest persist (in nsIPrincipal aPrincipal); */
    pub Persist: unsafe extern "system" fn (this: *const nsIQuotaManagerService, aPrincipal: *const nsIPrincipal, _retval: *mut *const nsIQuotaRequest) -> 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 nsIQuotaManagerService {

    /// ```text
    /// /**
    ///    * Initializes storage directory. This can be used in tests to verify
    ///    * upgrade methods.
    ///    *
    ///    * If the dom.quotaManager.testing preference is not true the call will be
    ///    * a no-op.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaRequest init ();`
    #[inline]
    pub unsafe fn Init(&self, _retval: *mut *const nsIQuotaRequest) -> nsresult {
        ((*self.vtable).Init)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Initializes storages for the given principal. This can be used in tests to
    ///    * verify origin initialization.
    ///    *
    ///    * If the dom.quotaManager.testing preference is not true the call will be
    ///    * a no-op.
    ///    *
    ///    * @param aPrincipal
    ///    *        A principal for the origin whose storages are to be initialized.
    ///    * @param aPersistenceType
    ///    *        A string that tells what persistence type of storages will be
    ///    *        initialized.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaRequest initStoragesForPrincipal (in nsIPrincipal aPrincipal, in ACString aPersistenceType);`
    #[inline]
    pub unsafe fn InitStoragesForPrincipal(&self, aPrincipal: *const nsIPrincipal, aPersistenceType: &::nsstring::nsACString, _retval: *mut *const nsIQuotaRequest) -> nsresult {
        ((*self.vtable).InitStoragesForPrincipal)(self, aPrincipal, aPersistenceType, _retval)
    }


    /// ```text
    /// /**
    ///    * Schedules an asynchronous callback that will inspect all origins and
    ///    * return the total amount of disk space being used by storages for each
    ///    * origin separately.
    ///    *
    ///    * @param aCallback
    ///    *        The callback that will be called when the usage is available.
    ///    * @param aGetAll
    ///    *        An optional boolean to indicate inspection of all origins,
    ///    *        including internal ones.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaUsageRequest getUsage (in nsIQuotaUsageCallback aCallback, [optional] in boolean aGetAll);`
    #[inline]
    pub unsafe fn GetUsage(&self, aCallback: *const nsIQuotaUsageCallback, aGetAll: bool, _retval: *mut *const nsIQuotaUsageRequest) -> nsresult {
        ((*self.vtable).GetUsage)(self, aCallback, aGetAll, _retval)
    }


    /// ```text
    /// /**
    ///    * Schedules an asynchronous callback that will return the total amount of
    ///    * disk space being used by storages for the given origin.
    ///    *
    ///    * @param aPrincipal
    ///    *        A principal for the origin whose usage is being queried.
    ///    * @param aCallback
    ///    *        The callback that will be called when the usage is available.
    ///    * @param aGetGroupUsage
    ///    *        An optional flag to indicate whether getting group usage and limit
    ///    *        or origin usage and file usage. The default value is false.
    ///    * Note:  Origin usage here represents total usage of an origin. However,
    ///    *        group usage here represents only non-persistent usage of a group.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaUsageRequest getUsageForPrincipal (in nsIPrincipal aPrincipal, in nsIQuotaUsageCallback aCallback, [optional] in boolean aGetGroupUsage);`
    #[inline]
    pub unsafe fn GetUsageForPrincipal(&self, aPrincipal: *const nsIPrincipal, aCallback: *const nsIQuotaUsageCallback, aGetGroupUsage: bool, _retval: *mut *const nsIQuotaUsageRequest) -> nsresult {
        ((*self.vtable).GetUsageForPrincipal)(self, aPrincipal, aCallback, aGetGroupUsage, _retval)
    }


    /// ```text
    /// /**
    ///    * Removes all storages. The files may not be deleted immediately depending
    ///    * on prohibitive concurrent operations.
    ///    * Be careful, this removes *all* the data that has ever been stored!
    ///    *
    ///    * If the dom.quotaManager.testing preference is not true the call will be
    ///    * a no-op.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaRequest clear ();`
    #[inline]
    pub unsafe fn Clear(&self, _retval: *mut *const nsIQuotaRequest) -> nsresult {
        ((*self.vtable).Clear)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Removes all storages stored for the given principal. The files may not be
    ///    * deleted immediately depending on prohibitive concurrent operations.
    ///    *
    ///    * @param aPrincipal
    ///    *        A principal for the origin whose storages are to be cleared.
    ///    * @param aPersistenceType
    ///    *        An optional string that tells what persistence type of storages
    ///    *        will be cleared.
    ///    * @param aClearAll
    ///    *        An optional boolean to indicate clearing all storages under the
    ///    *        given origin.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaRequest clearStoragesForPrincipal (in nsIPrincipal aPrincipal, [optional] in ACString aPersistenceType, [optional] in boolean aClearAll);`
    #[inline]
    pub unsafe fn ClearStoragesForPrincipal(&self, aPrincipal: *const nsIPrincipal, aPersistenceType: &::nsstring::nsACString, aClearAll: bool, _retval: *mut *const nsIQuotaRequest) -> nsresult {
        ((*self.vtable).ClearStoragesForPrincipal)(self, aPrincipal, aPersistenceType, aClearAll, _retval)
    }


    /// ```text
    /// /**
    ///    * Resets quota and storage management. This can be used to force
    ///    * reinitialization of the temp storage, for example when the pref for
    ///    * overriding the temp storage limit has changed.
    ///    * Be carefull, this invalidates all live storages!
    ///    *
    ///    * If the dom.quotaManager.testing preference is not true the call will be
    ///    * a no-op.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaRequest reset ();`
    #[inline]
    pub unsafe fn Reset(&self, _retval: *mut *const nsIQuotaRequest) -> nsresult {
        ((*self.vtable).Reset)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Check if given origin is persisted.
    ///    *
    ///    * @param aPrincipal
    ///    *        A principal for the origin which we want to check.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaRequest persisted (in nsIPrincipal aPrincipal);`
    #[inline]
    pub unsafe fn Persisted(&self, aPrincipal: *const nsIPrincipal, _retval: *mut *const nsIQuotaRequest) -> nsresult {
        ((*self.vtable).Persisted)(self, aPrincipal, _retval)
    }


    /// ```text
    /// /**
    ///    * Persist given origin.
    ///    *
    ///    * @param aPrincipal
    ///    *        A principal for the origin which we want to persist.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIQuotaRequest persist (in nsIPrincipal aPrincipal);`
    #[inline]
    pub unsafe fn Persist(&self, aPrincipal: *const nsIPrincipal, _retval: *mut *const nsIQuotaRequest) -> nsresult {
        ((*self.vtable).Persist)(self, aPrincipal, _retval)
    }


}