Struct xpcom::interfaces::nsIComponentRegistrar

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

interface nsIComponentRegistrar : nsISupports

Methods

impl nsIComponentRegistrar

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

Cast this nsIComponentRegistrar to one of its base interfaces.

impl nsIComponentRegistrar

pub unsafe fn AutoRegister(&self, aSpec: *const nsIFile) -> nsresult

/**
     * autoRegister
     *
     * Register a .manifest file, or an entire directory containing
     * these files. Registration lasts for this run only, and is not cached.
     *
     * @note Formerly this method would register component files directly. This
     *       is no longer supported.
     */

void autoRegister (in nsIFile aSpec);

pub unsafe fn AutoUnregister(&self, aSpec: *const nsIFile) -> nsresult

/**
     * autoUnregister
     * @status OBSOLETE: This method is no longer implemented, but preserved
     *                   in this interface for binary compatibility with
     *                   Mozilla 1.9.2.
     */

void autoUnregister (in nsIFile aSpec);

pub unsafe fn RegisterFactory(
    &self,
    aClass: &nsCID,
    aClassName: *const c_char,
    aContractID: *const c_char,
    aFactory: *const nsIFactory
) -> nsresult

/**
     * registerFactory
     *
     * Register a factory with a given ContractID, CID and Class Name.
     *
     * @param aClass      : CID of object
     * @param aClassName  : Class Name of CID (unused)
     * @param aContractID : ContractID associated with CID aClass. May be null
     *                      if no contract ID is needed.
     * @param aFactory    : Factory that will be registered for CID aClass.
     *                      If aFactory is null, the contract will be associated
     *                      with a previously registered CID.
     */

void registerFactory (in nsCIDRef aClass, in string aClassName, in string aContractID, in nsIFactory aFactory);

pub unsafe fn UnregisterFactory(
    &self,
    aClass: &nsCID,
    aFactory: *const nsIFactory
) -> nsresult

/**
     * unregisterFactory
     *
     * Unregister a factory associated with CID aClass.
     *
     * @param aClass   : CID being unregistered
     * @param aFactory : Factory previously registered to create instances of
     *                   CID aClass.
     *
     * @throws NS_ERROR* Method failure.
     */

void unregisterFactory (in nsCIDRef aClass, in nsIFactory aFactory);

pub unsafe fn RegisterFactoryLocation(
    &self,
    aClass: &nsCID,
    aClassName: *const c_char,
    aContractID: *const c_char,
    aFile: *const nsIFile,
    aLoaderStr: *const c_char,
    aType: *const c_char
) -> nsresult

/**
     * registerFactoryLocation
     * @status OBSOLETE: This method is no longer implemented, but preserved
     *                   in this interface for binary compatibility with
     *                   Mozilla 1.9.2.
     */

void registerFactoryLocation (in nsCIDRef aClass, in string aClassName, in string aContractID, in nsIFile aFile, in string aLoaderStr, in string aType);

pub unsafe fn UnregisterFactoryLocation(
    &self,
    aClass: &nsCID,
    aFile: *const nsIFile
) -> nsresult

/**
     * unregisterFactoryLocation
     * @status OBSOLETE: This method is no longer implemented, but preserved
     *                   in this interface for binary compatibility with
     *                   Mozilla 1.9.2.
     */

void unregisterFactoryLocation (in nsCIDRef aClass, in nsIFile aFile);

pub unsafe fn IsCIDRegistered(
    &self,
    aClass: &nsCID,
    _retval: *mut bool
) -> nsresult

/**
     * isCIDRegistered
     *
     * Returns true if a factory is registered for the CID.
     *
     * @param aClass : CID queried for registeration
     * @return       : true if a factory is registered for CID
     *                 false otherwise.
     */

boolean isCIDRegistered (in nsCIDRef aClass);

pub unsafe fn IsContractIDRegistered(
    &self,
    aContractID: *const c_char,
    _retval: *mut bool
) -> nsresult

/**
     * isContractIDRegistered
     *
     * Returns true if a factory is registered for the contract id.
     *
     * @param aClass : contract id queried for registeration
     * @return       : true if a factory is registered for contract id
     *                 false otherwise.
     */

boolean isContractIDRegistered (in string aContractID);

pub unsafe fn EnumerateCIDs(
    &self,
    _retval: *mut *const nsISimpleEnumerator
) -> nsresult

/**
     * enumerateCIDs
     *
     * Enumerate the list of all registered CIDs.
     *
     * @return : enumerator for CIDs.  Elements of the enumeration can be QI'ed
     *           for the nsISupportsID interface.  From the nsISupportsID, you
     *           can obtain the actual CID.
     */

nsISimpleEnumerator enumerateCIDs ();

pub unsafe fn EnumerateContractIDs(
    &self,
    _retval: *mut *const nsISimpleEnumerator
) -> nsresult

/**
     * enumerateContractIDs
     *
     * Enumerate the list of all registered ContractIDs.
     *
     * @return : enumerator for ContractIDs. Elements of the enumeration can be
     *           QI'ed for the nsISupportsCString interface.  From  the
     *           nsISupportsCString interface, you can obtain the actual
     *           Contract ID string.
     */

nsISimpleEnumerator enumerateContractIDs ();

pub unsafe fn CIDToContractID(
    &self,
    aClass: &nsCID,
    _retval: *mut *const c_char
) -> nsresult

/**
     * CIDToContractID
     * @status OBSOLETE: This method is no longer implemented, but preserved
     *                   in this interface for binary compatibility with
     *                   Mozilla 1.9.2.
     */

string CIDToContractID (in nsCIDRef aClass);

pub unsafe fn ContractIDToCID(
    &self,
    aContractID: *const c_char,
    _retval: *mut *mut nsCID
) -> nsresult

/**
     * contractIDToCID
     *
     * Returns the CID for a given Contract ID, if one exists and is registered.
     *
     * @return : Contract ID.
     */

nsCIDPtr contractIDToCID (in string aContractID);

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 nsIComponentRegistrar

const IID: nsIID

IID: nsIID = nsID(605539326, 26029, 18598, [180, 182, 235, 132, 219, 23, 67, 146])

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 nsIComponentRegistrar

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIComponentRegistrar

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.