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


/// `interface nsIProfilerStartParams : nsISupports`
///

/// ```text
/// /**
///  * Start-up parameters for subprocesses are passed through nsIObserverService,
///  * which, unfortunately, means we need to implement nsISupports in order to
///  * go through it.
///  */
/// ```
///

// 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 nsIProfilerStartParams {
    vtable: *const nsIProfilerStartParamsVTable,

    /// 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 nsIProfilerStartParams.
unsafe impl XpCom for nsIProfilerStartParams {
    const IID: nsIID = nsID(0x0a175ba7, 0x8fcf, 0x4ce9,
        [0x9c, 0x4b, 0xcc, 0xc6, 0x27, 0x2f, 0x44, 0x25]);
}

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

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

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

    /* readonly attribute uint32_t entries; */
    pub GetEntries: unsafe extern "system" fn (this: *const nsIProfilerStartParams, aEntries: *mut uint32_t) -> nsresult,

    /* readonly attribute double interval; */
    pub GetInterval: unsafe extern "system" fn (this: *const nsIProfilerStartParams, aInterval: *mut libc::c_double) -> nsresult,

    /* readonly attribute uint32_t features; */
    pub GetFeatures: unsafe extern "system" fn (this: *const nsIProfilerStartParams, aFeatures: *mut uint32_t) -> nsresult,

    /* [noscript,nostdcall,notxpcom] StringArrayRef getFilters (); */
    /// Unable to generate binding because `nostdcall is unsupported`
    pub GetFilters: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIProfilerStartParams {


    /// `readonly attribute uint32_t entries;`
    #[inline]
    pub unsafe fn GetEntries(&self, aEntries: *mut uint32_t) -> nsresult {
        ((*self.vtable).GetEntries)(self, aEntries)
    }



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



    /// `readonly attribute uint32_t features;`
    #[inline]
    pub unsafe fn GetFeatures(&self, aFeatures: *mut uint32_t) -> nsresult {
        ((*self.vtable).GetFeatures)(self, aFeatures)
    }



    /// `[noscript,nostdcall,notxpcom] StringArrayRef getFilters ();`
    const _GetFilters: () = ();

}


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

    /// 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 nsIProfiler.
unsafe impl XpCom for nsIProfiler {
    const IID: nsIID = nsID(0xead3f75c, 0x0e0e, 0x4fbb,
        [0x90, 0x1c, 0x1e, 0x53, 0x92, 0xef, 0x5b, 0x2a]);
}

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

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

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

    /* boolean CanProfile (); */
    pub CanProfile: unsafe extern "system" fn (this: *const nsIProfiler, _retval: *mut bool) -> nsresult,

    /* void StartProfiler (in uint32_t aEntries, in double aInterval, [array, size_is (aFeatureCount)] in string aFeatures, in uint32_t aFeatureCount, [array, size_is (aFilterCount), optional] in string aFilters, [optional] in uint32_t aFilterCount); */
    pub StartProfiler: unsafe extern "system" fn (this: *const nsIProfiler, aEntries: uint32_t, aInterval: libc::c_double, aFeatures: *mut *const libc::c_char, aFeatureCount: uint32_t, aFilters: *mut *const libc::c_char, aFilterCount: uint32_t) -> nsresult,

    /* void StopProfiler (); */
    pub StopProfiler: unsafe extern "system" fn (this: *const nsIProfiler) -> nsresult,

    /* boolean IsPaused (); */
    pub IsPaused: unsafe extern "system" fn (this: *const nsIProfiler, _retval: *mut bool) -> nsresult,

    /* void PauseSampling (); */
    pub PauseSampling: unsafe extern "system" fn (this: *const nsIProfiler) -> nsresult,

    /* void ResumeSampling (); */
    pub ResumeSampling: unsafe extern "system" fn (this: *const nsIProfiler) -> nsresult,

    /* void AddMarker (in string aMarker); */
    pub AddMarker: unsafe extern "system" fn (this: *const nsIProfiler, aMarker: *const libc::c_char) -> nsresult,

    /* string GetProfile ([optional] in double aSinceTime); */
    pub GetProfile: unsafe extern "system" fn (this: *const nsIProfiler, aSinceTime: libc::c_double, _retval: *mut *const libc::c_char) -> nsresult,

    /* [implicit_jscontext] jsval getProfileData ([optional] in double aSinceTime); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub GetProfileData: *const ::libc::c_void,

    /* [implicit_jscontext] nsISupports getProfileDataAsync ([optional] in double aSinceTime); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub GetProfileDataAsync: *const ::libc::c_void,

    /* [implicit_jscontext] nsISupports getProfileDataAsArrayBuffer ([optional] in double aSinceTime); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub GetProfileDataAsArrayBuffer: *const ::libc::c_void,

    /* [implicit_jscontext] nsISupports dumpProfileToFileAsync (in ACString aFilename, [optional] in double aSinceTime); */
    /// Unable to generate binding because `jscontext is unsupported`
    pub DumpProfileToFileAsync: *const ::libc::c_void,

    /* boolean IsActive (); */
    pub IsActive: unsafe extern "system" fn (this: *const nsIProfiler, _retval: *mut bool) -> nsresult,

    /* void GetFeatures (out uint32_t aCount, [array, size_is (aCount), retval] out string aFeatures); */
    pub GetFeatures: unsafe extern "system" fn (this: *const nsIProfiler, aCount: *mut uint32_t, aFeatures: *mut *mut *const libc::c_char) -> nsresult,

    /* void GetAllFeatures (out uint32_t aCount, [array, size_is (aCount), retval] out string aFeatures); */
    pub GetAllFeatures: unsafe extern "system" fn (this: *const nsIProfiler, aCount: *mut uint32_t, aFeatures: *mut *mut *const libc::c_char) -> nsresult,

    /* [noscript] readonly attribute nsIProfilerStartParams startParams; */
    pub GetStartParams: unsafe extern "system" fn (this: *const nsIProfiler, aStartParams: *mut *const nsIProfilerStartParams) -> nsresult,

    /* void GetBufferInfo (out uint32_t aCurrentPosition, out uint32_t aTotalSize, out uint32_t aGeneration); */
    pub GetBufferInfo: unsafe extern "system" fn (this: *const nsIProfiler, aCurrentPosition: *mut uint32_t, aTotalSize: *mut uint32_t, aGeneration: *mut uint32_t) -> nsresult,

    /* double getElapsedTime (); */
    pub GetElapsedTime: unsafe extern "system" fn (this: *const nsIProfiler, _retval: *mut libc::c_double) -> nsresult,

    /* [implicit_jscontext] readonly attribute jsval sharedLibraries; */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetSharedLibraries: *const ::libc::c_void,

    /* void dumpProfileToFile (in string aFilename); */
    pub DumpProfileToFile: unsafe extern "system" fn (this: *const nsIProfiler, aFilename: *const libc::c_char) -> nsresult,

    /* [noscript,nostdcall,notxpcom] void receiveShutdownProfile (in nsCString aProfile); */
    /// Unable to generate binding because `native type const nsCString is unsupported`
    pub ReceiveShutdownProfile: *const ::libc::c_void,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIProfiler {


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



    /// `void StartProfiler (in uint32_t aEntries, in double aInterval, [array, size_is (aFeatureCount)] in string aFeatures, in uint32_t aFeatureCount, [array, size_is (aFilterCount), optional] in string aFilters, [optional] in uint32_t aFilterCount);`
    #[inline]
    pub unsafe fn StartProfiler(&self, aEntries: uint32_t, aInterval: libc::c_double, aFeatures: *mut *const libc::c_char, aFeatureCount: uint32_t, aFilters: *mut *const libc::c_char, aFilterCount: uint32_t) -> nsresult {
        ((*self.vtable).StartProfiler)(self, aEntries, aInterval, aFeatures, aFeatureCount, aFilters, aFilterCount)
    }



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



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



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



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



    /// `void AddMarker (in string aMarker);`
    #[inline]
    pub unsafe fn AddMarker(&self, aMarker: *const libc::c_char) -> nsresult {
        ((*self.vtable).AddMarker)(self, aMarker)
    }



    /// `string GetProfile ([optional] in double aSinceTime);`
    #[inline]
    pub unsafe fn GetProfile(&self, aSinceTime: libc::c_double, _retval: *mut *const libc::c_char) -> nsresult {
        ((*self.vtable).GetProfile)(self, aSinceTime, _retval)
    }



    /// `[implicit_jscontext] jsval getProfileData ([optional] in double aSinceTime);`
    const _GetProfileData: () = ();


    /// `[implicit_jscontext] nsISupports getProfileDataAsync ([optional] in double aSinceTime);`
    const _GetProfileDataAsync: () = ();


    /// `[implicit_jscontext] nsISupports getProfileDataAsArrayBuffer ([optional] in double aSinceTime);`
    const _GetProfileDataAsArrayBuffer: () = ();

    /// ```text
    /// /**
    ///    * Returns a promise that resolves once the file has been written.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext] nsISupports dumpProfileToFileAsync (in ACString aFilename, [optional] in double aSinceTime);`
    const _DumpProfileToFileAsync: () = ();


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


    /// ```text
    /// /**
    ///    * Returns an array of the features that are supported in this build.
    ///    * Features may vary depending on platform and build flags.
    ///    */
    /// ```
    ///

    /// `void GetFeatures (out uint32_t aCount, [array, size_is (aCount), retval] out string aFeatures);`
    #[inline]
    pub unsafe fn GetFeatures(&self, aCount: *mut uint32_t, aFeatures: *mut *mut *const libc::c_char) -> nsresult {
        ((*self.vtable).GetFeatures)(self, aCount, aFeatures)
    }


    /// ```text
    /// /**
    ///    * Returns an array of all features that are supported by the profiler.
    ///    * The array may contain features that are not supported in this build.
    ///    */
    /// ```
    ///

    /// `void GetAllFeatures (out uint32_t aCount, [array, size_is (aCount), retval] out string aFeatures);`
    #[inline]
    pub unsafe fn GetAllFeatures(&self, aCount: *mut uint32_t, aFeatures: *mut *mut *const libc::c_char) -> nsresult {
        ((*self.vtable).GetAllFeatures)(self, aCount, aFeatures)
    }


    /// ```text
    /// /**
    ///    * The starting parameters that were sent to the profiler for sampling.
    ///    * If the profiler is not currently sampling, this will return null.
    ///    */
    /// ```
    ///

    /// `[noscript] readonly attribute nsIProfilerStartParams startParams;`
    #[inline]
    pub unsafe fn GetStartParams(&self, aStartParams: *mut *const nsIProfilerStartParams) -> nsresult {
        ((*self.vtable).GetStartParams)(self, aStartParams)
    }



    /// `void GetBufferInfo (out uint32_t aCurrentPosition, out uint32_t aTotalSize, out uint32_t aGeneration);`
    #[inline]
    pub unsafe fn GetBufferInfo(&self, aCurrentPosition: *mut uint32_t, aTotalSize: *mut uint32_t, aGeneration: *mut uint32_t) -> nsresult {
        ((*self.vtable).GetBufferInfo)(self, aCurrentPosition, aTotalSize, aGeneration)
    }


    /// ```text
    /// /**
    ///    * Returns the elapsed time, in milliseconds, since the profiler's epoch.
    ///    * The epoch is guaranteed to be constant for the duration of the
    ///    * process, but is otherwise arbitrary.
    ///    */
    /// ```
    ///

    /// `double getElapsedTime ();`
    #[inline]
    pub unsafe fn GetElapsedTime(&self, _retval: *mut libc::c_double) -> nsresult {
        ((*self.vtable).GetElapsedTime)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Contains an array of shared library objects.
    ///    * Every object has the properties:
    ///    *  - start:      The start address of the memory region occupied by this library.
    ///    *  - end:        The end address of the memory region occupied by this library.
    ///    *  - offset:     Usually zero, except on Android if the region was mapped from
    ///    *                a file (using mmap), then this is the offset in the file where
    ///    *                the mapping begins.
    ///    *  - name:       The name (file basename) of the binary.
    ///    *  - path:       The full absolute path to the binary.
    ///    *  - debugName:  On Windows, the name of the pdb file for the binary. On other
    ///    *                platforms, the same as |name|.
    ///    *  - debugPath:  On Windows, the full absolute path of the pdb file for the
    ///    *                binary. On other platforms, the same as |path|.
    ///    *  - arch:       On Mac, the name of the architecture that identifies the right
    ///    *                binary image of a fat binary. Example values are "i386", "x86_64",
    ///    *                and "x86_64h". (x86_64h is used for binaries that contain
        ///    *                instructions that are specific to the Intel Haswell microarchitecture.)
    ///    *                On non-Mac platforms, arch is "".
    ///    *  - breakpadId: A unique identifier string for this library, as used by breakpad.
    ///    */
    /// ```
    ///

    /// `[implicit_jscontext] readonly attribute jsval sharedLibraries;`
    const _GetSharedLibraries: () = ();

    /// ```text
    /// /**
    ///    * Dump the collected profile to a file.
    ///    */
    /// ```
    ///

    /// `void dumpProfileToFile (in string aFilename);`
    #[inline]
    pub unsafe fn DumpProfileToFile(&self, aFilename: *const libc::c_char) -> nsresult {
        ((*self.vtable).DumpProfileToFile)(self, aFilename)
    }



    /// `[noscript,nostdcall,notxpcom] void receiveShutdownProfile (in nsCString aProfile);`
    const _ReceiveShutdownProfile: () = ();

}