Struct xpcom::interfaces::nsIModule

#[repr(C)]
pub struct nsIModule { /* fields omitted */ }

interface nsIModule : nsISupports

/**
 * The nsIModule interface.
 */

Methods

impl nsIModule

pub fn coerce<T: nsIModuleCoerce>(&self) -> &T

Cast this nsIModule to one of its base interfaces.

impl nsIModule

pub unsafe fn GetClassObject(
    &self,
    aCompMgr: *const nsIComponentManager,
    aClass: &nsCID,
    aIID: &nsIID,
    aResult: *mut *mut c_void
) -> nsresult

/**
     * Object Instance Creation
     *
     * Obtains a Class Object from a nsIModule for a given CID and IID pair.
     * This class object can either be query to a nsIFactory or a may be
     * query to a nsIClassInfo.
     *
     * @param aCompMgr  : The global component manager
     * @param aClass    : ClassID of object instance requested
     * @param aIID      : IID of interface requested
     *
     */

void getClassObject (in nsIComponentManager aCompMgr, in nsCIDRef aClass, in nsIIDRef aIID, [iid_is (aIID), retval] out nsQIResult aResult);

pub unsafe fn RegisterSelf(
    &self,
    aCompMgr: *const nsIComponentManager,
    aLocation: *const nsIFile,
    aLoaderStr: *const c_char,
    aType: *const c_char
) -> nsresult

/**
     * One time registration callback
     *
     * When the nsIModule is discovered, this method will be
     * called so that any setup registration can be preformed.
     *
     * @param aCompMgr  : The global component manager
     * @param aLocation : The location of the nsIModule on disk
     * @param aLoaderStr: Opaque loader specific string
     * @param aType     : Loader Type being used to load this module
     */

void registerSelf (in nsIComponentManager aCompMgr, in nsIFile aLocation, in string aLoaderStr, in string aType);

pub unsafe fn UnregisterSelf(
    &self,
    aCompMgr: *const nsIComponentManager,
    aLocation: *const nsIFile,
    aLoaderStr: *const c_char
) -> nsresult

/**
     * One time unregistration callback
     *
     * When the nsIModule is being unregistered, this method will be
     * called so that any unregistration can be preformed
     *
     * @param aCompMgr   : The global component manager
     * @param aLocation  : The location of the nsIModule on disk
     * @param aLoaderStr : Opaque loader specific string
     *
     */

void unregisterSelf (in nsIComponentManager aCompMgr, in nsIFile aLocation, in string aLoaderStr);

pub unsafe fn CanUnload(
    &self,
    aCompMgr: *const nsIComponentManager,
    _retval: *mut bool
) -> nsresult

/**
    * Module load management
    *
    * @param aCompMgr  : The global component manager
    *
    * @return indicates to the caller if the module can be unloaded.
    *       Returning PR_TRUE isn't a guarantee that the module will be
    *       unloaded. It constitues only willingness of the module to be
    *       unloaded.  It is very important to ensure that no outstanding
    *       references to the module's code/data exist before returning
    *       PR_TRUE.
    *       Returning PR_FALSE guaratees that the module won't be unloaded.
    */

boolean canUnload (in nsIComponentManager aCompMgr);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIModule

const IID: nsIID

IID: nsIID = nsID(1939001394, 21361, 4563, [153, 78, 0, 128, 95, 210, 111, 238])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIModule

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIModule

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.