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


/// `interface nsIDownload : nsITransfer`
///

/// ```text
/// /**
///  * Represents a download object.
///  *
///  * @note This object is no longer updated once it enters a completed state.
///  *       Completed states are the following:
///  *       nsIDownloadManager::DOWNLOAD_FINISHED
///  *       nsIDownloadManager::DOWNLOAD_FAILED
///  *       nsIDownloadManager::DOWNLOAD_CANCELED
///  *       nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL
///  *       nsIDownloadManager::DOWNLOAD_DIRTY
///  *       nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY
///  */
/// ```
///

// 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 nsIDownload {
    vtable: *const nsIDownloadVTable,

    /// 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 nsIDownload.
unsafe impl XpCom for nsIDownload {
    const IID: nsIID = nsID(0x2258f465, 0x656e, 0x4566,
        [0x87, 0xcb, 0xf7, 0x91, 0xdb, 0xaf, 0x03, 0x22]);
}

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

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

impl nsIDownload {
    /// Cast this `nsIDownload` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIDownloadCoerce>(&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 nsIDownload {
    type Target = nsITransfer;
    #[inline]
    fn deref(&self) -> &nsITransfer {
        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: nsITransferCoerce> nsIDownloadCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIDownload) -> &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 nsIDownload
// 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 nsIDownloadVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsITransferVTable,

    /* readonly attribute nsIFile targetFile; */
    pub GetTargetFile: unsafe extern "system" fn (this: *const nsIDownload, aTargetFile: *mut *const nsIFile) -> nsresult,

    /* readonly attribute long percentComplete; */
    pub GetPercentComplete: unsafe extern "system" fn (this: *const nsIDownload, aPercentComplete: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long long amountTransferred; */
    pub GetAmountTransferred: unsafe extern "system" fn (this: *const nsIDownload, aAmountTransferred: *mut libc::int64_t) -> nsresult,

    /* readonly attribute long long size; */
    pub GetSize: unsafe extern "system" fn (this: *const nsIDownload, aSize: *mut libc::int64_t) -> nsresult,

    /* readonly attribute nsIURI source; */
    pub GetSource: unsafe extern "system" fn (this: *const nsIDownload, aSource: *mut *const nsIURI) -> nsresult,

    /* readonly attribute nsIURI target; */
    pub GetTarget: unsafe extern "system" fn (this: *const nsIDownload, aTarget: *mut *const nsIURI) -> nsresult,

    /* readonly attribute nsICancelable cancelable; */
    pub GetCancelable: unsafe extern "system" fn (this: *const nsIDownload, aCancelable: *mut *const nsICancelable) -> nsresult,

    /* readonly attribute AString displayName; */
    pub GetDisplayName: unsafe extern "system" fn (this: *const nsIDownload, aDisplayName: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute long long startTime; */
    pub GetStartTime: unsafe extern "system" fn (this: *const nsIDownload, aStartTime: *mut libc::int64_t) -> nsresult,

    /* readonly attribute double speed; */
    pub GetSpeed: unsafe extern "system" fn (this: *const nsIDownload, aSpeed: *mut libc::c_double) -> nsresult,

    /* readonly attribute nsIMIMEInfo MIMEInfo; */
    pub GetMIMEInfo: unsafe extern "system" fn (this: *const nsIDownload, aMIMEInfo: *mut *const nsIMIMEInfo) -> nsresult,

    /* readonly attribute unsigned long id; */
    pub GetId: unsafe extern "system" fn (this: *const nsIDownload, aId: *mut libc::uint32_t) -> nsresult,

    /* readonly attribute ACString guid; */
    pub GetGuid: unsafe extern "system" fn (this: *const nsIDownload, aGuid: &mut ::nsstring::nsACString) -> nsresult,

    /* readonly attribute short state; */
    pub GetState: unsafe extern "system" fn (this: *const nsIDownload, aState: *mut libc::int16_t) -> nsresult,

    /* readonly attribute nsIURI referrer; */
    pub GetReferrer: unsafe extern "system" fn (this: *const nsIDownload, aReferrer: *mut *const nsIURI) -> nsresult,

    /* readonly attribute boolean resumable; */
    pub GetResumable: unsafe extern "system" fn (this: *const nsIDownload, aResumable: *mut bool) -> nsresult,

    /* readonly attribute boolean isPrivate; */
    pub GetIsPrivate: unsafe extern "system" fn (this: *const nsIDownload, aIsPrivate: *mut bool) -> nsresult,

    /* void cancel (); */
    pub Cancel: unsafe extern "system" fn (this: *const nsIDownload) -> nsresult,

    /* void pause (); */
    pub Pause: unsafe extern "system" fn (this: *const nsIDownload) -> nsresult,

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

    /* void remove (); */
    pub Remove: unsafe extern "system" fn (this: *const nsIDownload) -> nsresult,

    /* void retry (); */
    pub Retry: unsafe extern "system" fn (this: *const nsIDownload) -> 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 nsIDownload {

    /// ```text
    /// /**
    ///      * The target of a download is always a file on the local file system.
    ///      */
    /// ```
    ///

    /// `readonly attribute nsIFile targetFile;`
    #[inline]
    pub unsafe fn GetTargetFile(&self, aTargetFile: *mut *const nsIFile) -> nsresult {
        ((*self.vtable).GetTargetFile)(self, aTargetFile)
    }


    /// ```text
    /// /**
    ///      * The percentage of transfer completed.
    ///      * If the file size is unknown it'll be -1 here.
    ///      */
    /// ```
    ///

    /// `readonly attribute long percentComplete;`
    #[inline]
    pub unsafe fn GetPercentComplete(&self, aPercentComplete: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetPercentComplete)(self, aPercentComplete)
    }


    /// ```text
    /// /**
    ///      * The amount of bytes downloaded so far.
    ///      */
    /// ```
    ///

    /// `readonly attribute long long amountTransferred;`
    #[inline]
    pub unsafe fn GetAmountTransferred(&self, aAmountTransferred: *mut libc::int64_t) -> nsresult {
        ((*self.vtable).GetAmountTransferred)(self, aAmountTransferred)
    }


    /// ```text
    /// /**
    ///      * The size of file in bytes.
    ///      * Unknown size is represented by -1.
    ///      */
    /// ```
    ///

    /// `readonly attribute long long size;`
    #[inline]
    pub unsafe fn GetSize(&self, aSize: *mut libc::int64_t) -> nsresult {
        ((*self.vtable).GetSize)(self, aSize)
    }


    /// ```text
    /// /**
    ///      * The source of the transfer.
    ///      */
    /// ```
    ///

    /// `readonly attribute nsIURI source;`
    #[inline]
    pub unsafe fn GetSource(&self, aSource: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetSource)(self, aSource)
    }


    /// ```text
    /// /**
    ///      * The target of the transfer.
    ///      */
    /// ```
    ///

    /// `readonly attribute nsIURI target;`
    #[inline]
    pub unsafe fn GetTarget(&self, aTarget: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetTarget)(self, aTarget)
    }


    /// ```text
    /// /**
    ///      * Object that can be used to cancel the download.
    ///      * Will be null after the download is finished.
    ///      */
    /// ```
    ///

    /// `readonly attribute nsICancelable cancelable;`
    #[inline]
    pub unsafe fn GetCancelable(&self, aCancelable: *mut *const nsICancelable) -> nsresult {
        ((*self.vtable).GetCancelable)(self, aCancelable)
    }


    /// ```text
    /// /**
    ///      * The user-readable description of the transfer.
    ///      */
    /// ```
    ///

    /// `readonly attribute AString displayName;`
    #[inline]
    pub unsafe fn GetDisplayName(&self, aDisplayName: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetDisplayName)(self, aDisplayName)
    }


    /// ```text
    /// /**
    ///      * The time a transfer was started.
    ///      */
    /// ```
    ///

    /// `readonly attribute long long startTime;`
    #[inline]
    pub unsafe fn GetStartTime(&self, aStartTime: *mut libc::int64_t) -> nsresult {
        ((*self.vtable).GetStartTime)(self, aStartTime)
    }


    /// ```text
    /// /**
    ///      * The speed of the transfer in bytes/sec.
    ///      */
    /// ```
    ///

    /// `readonly attribute double speed;`
    #[inline]
    pub unsafe fn GetSpeed(&self, aSpeed: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetSpeed)(self, aSpeed)
    }


    /// ```text
    /// /**
    ///      * Optional. If set, it will contain the target's relevant MIME information.
    ///      * This includes its MIME Type, helper app, and whether that helper should be
    ///      * executed.
    ///      */
    /// ```
    ///

    /// `readonly attribute nsIMIMEInfo MIMEInfo;`
    #[inline]
    pub unsafe fn GetMIMEInfo(&self, aMIMEInfo: *mut *const nsIMIMEInfo) -> nsresult {
        ((*self.vtable).GetMIMEInfo)(self, aMIMEInfo)
    }


    /// ```text
    /// /**
    ///      * The id of the download that is stored in the database - not globally unique.
    ///      * For example, a private download and a public one might have identical ids.
    ///      * Can only be safely used for direct database manipulation in the database that
    ///      * contains this download. Use the guid property instead for safe, database-agnostic
    ///      * searching and manipulation.
    ///      *
    ///      * @deprecated
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * The guid of the download that is stored in the database.
    ///      * Has the form of twelve alphanumeric characters.
    ///      */
    /// ```
    ///

    /// `readonly attribute ACString guid;`
    #[inline]
    pub unsafe fn GetGuid(&self, aGuid: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetGuid)(self, aGuid)
    }


    /// ```text
    /// /**
    ///      * The state of the download.
    ///      * @see nsIDownloadManager and nsIXPInstallManagerUI
    ///      */
    /// ```
    ///

    /// `readonly attribute short state;`
    #[inline]
    pub unsafe fn GetState(&self, aState: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).GetState)(self, aState)
    }


    /// ```text
    /// /**
    ///      * The referrer uri of the download.  This is only valid for HTTP downloads,
    ///      * and can be null.
    ///      */
    /// ```
    ///

    /// `readonly attribute nsIURI referrer;`
    #[inline]
    pub unsafe fn GetReferrer(&self, aReferrer: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetReferrer)(self, aReferrer)
    }


    /// ```text
    /// /**
    ///      * Indicates if the download can be resumed after being paused or not.  This
    ///      * is only the case if the download is over HTTP/1.1 or FTP and if the
    ///      * server supports it.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Indicates if the download was initiated from a context marked as private,
    ///      * controlling whether it should be stored in a permanent manner or not.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Cancel this download if it's currently in progress.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Pause this download if it is in progress.
    ///      *
    ///      * @throws NS_ERROR_UNEXPECTED if it cannot be paused.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Resume this download if it is paused.
    ///      *
    ///      * @throws NS_ERROR_UNEXPECTED if it cannot be resumed or is not paused.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Instruct the download manager to remove this download. Whereas
    ///      * cancel simply cancels the transfer, but retains information about it,
    ///      * remove removes all knowledge of it.
    ///      *
    ///      * @see nsIDownloadManager.removeDownload for more detail
    ///      * @throws NS_ERROR_FAILURE if the download is active.
    ///      */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///      * Instruct the download manager to retry this failed download
    ///      * @throws NS_ERROR_NOT_AVAILABLE if the download is not known.
    ///      * @throws NS_ERROR_FAILURE if the download is not in the following states:
    ///      *         nsIDownloadManager::DOWNLOAD_CANCELED
    ///      *         nsIDownloadManager::DOWNLOAD_FAILED
    ///      */
    /// ```
    ///

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


}