#ifndef nsComponentManagerObsolete_h___

#define nsComponentManagerObsolete_h___

#include "nsIComponentManager.h"

#include "nsIComponentManagerObsolete.h"

class nsIEnumerator;

class nsIFactory;

class nsIFile;

extern NS_COM nsresult

NS_GetGlobalComponentManager(nsIComponentManager* *result);

class NS_COM nsComponentManager {

public:

static nsresult Initialize(void);

// Finds a factory for a specific class ID

static nsresult FindFactory(const nsCID &aClass,

nsIFactory **aFactory);

// Get the singleton class object that implements the CID aClass

static nsresult GetClassObject(const nsCID &aClass, const nsIID &aIID,

void **aResult);

// Finds a class ID for a specific Program ID

static nsresult ContractIDToClassID(const char *aContractID,

nsCID *aClass);

// Finds a Program ID for a specific class ID

// caller frees the result with delete[]

static nsresult CLSIDToContractID(nsCID *aClass,

char* *aClassName,

char* *aContractID);

// Creates a class instance for a specific class ID

static nsresult CreateInstance(const nsCID &aClass,

nsISupports *aDelegate,

const nsIID &aIID,

void **aResult);

// Convenience routine, creates a class instance for a specific ContractID

static nsresult CreateInstance(const char *aContractID,

nsISupports *aDelegate,

const nsIID &aIID,

void **aResult);

// Manually registry a factory for a class

static nsresult RegisterFactory(const nsCID &aClass,

const char *aClassName,

const char *aContractID,

nsIFactory *aFactory,

PRBool aReplace);

// Manually register a dynamically loaded component.

// The libraryPersistentDescriptor is what gets passed to the library

// self register function from ComponentManager. The format of this string

// is the same as nsIFile::GetPath()

//

// This function will go away in favour of RegisterComponentSpec. In fact,

// it internally turns around and calls RegisterComponentSpec.

static nsresult RegisterComponent(const nsCID &aClass,

const char *aClassName,

const char *aContractID,

const char *aLibraryPersistentDescriptor,

PRBool aReplace,

PRBool aPersist);

// Register a component using its FileSpec as its identification

// This is the more prevalent use.

static nsresult RegisterComponentSpec(const nsCID &aClass,

const char *aClassName,

const char *aContractID,

nsIFile *aLibrary,

PRBool aReplace,

PRBool aPersist);

// Register a component using its dllName. This could be a dll name with

// no path so that LD_LIBRARY_PATH on unix or PATH on win can load it. Or

// this could be a code fragment name on the Mac.

static nsresult RegisterComponentLib(const nsCID &aClass,

const char *aClassName,

const char *aContractID,

const char *adllName,

PRBool aReplace,

PRBool aPersist);

// Manually unregister a factory for a class

static nsresult UnregisterFactory(const nsCID &aClass,

nsIFactory *aFactory);

// Manually unregister a dynamically loaded component

static nsresult UnregisterComponent(const nsCID &aClass,

const char *aLibrary);

// Manually unregister a dynamically loaded component

static nsresult UnregisterComponentSpec(const nsCID &aClass,

nsIFile *aLibrarySpec);

// Unload dynamically loaded factories that are not in use

static nsresult FreeLibraries(void);

//////////////////////////////////////////////////////////////////////////////

// DLL registration support

// If directory is NULL, then AutoRegister will try registering components

// in the default components directory.

static nsresult AutoRegister(PRInt32 when, nsIFile* directory);

static nsresult AutoRegisterComponent(PRInt32 when, nsIFile *component);

static nsresult AutoUnregisterComponent(PRInt32 when, nsIFile *component);

// Is the given CID currently registered?

static nsresult IsRegistered(const nsCID &aClass,

PRBool *aRegistered);

// Get an enumeration of all the CIDs

static nsresult EnumerateCLSIDs(nsIEnumerator** aEmumerator);

// Get an enumeration of all the ContractIDs

static nsresult EnumerateContractIDs(nsIEnumerator** aEmumerator);

};

#endif