CRegistryData Class Reference

class CRegistryData : public CBase

class CRegistryData. This class manages the entire data of the registry.

Inherits from

Public Member Functions
~CRegistryData()
voidAddDllDataL(const TDriveUnit &, TInt, CDllData *)
voidDiscoveriesBeginning()
voidDiscoveriesCompleteL(TBool, TPluginProcessingTypeIdentifier, TBool &)
TInt FindDriveL(const TDriveUnit &, CDriveData *&)
TInt GetImplementationDllInfoForClientL(const TClientRequest &, const TUid, const TUid, TEntry &, CImplementationInformation *&, TBool)
TInt GetImplementationDllInfoForServer(const TCapabilitySet &, const TUid, const TUid, TEntry &, CImplementationInformation *&, TBool &)
TBool HasLanguageChanged()
TBool IndexValid()
TBool InsertIntoIndexL(CImplementationData *, TBool)
TBool IsAnyDllRegisteredWithDriveL(const TDriveUnit &)
TBool IsRegisteredWithDate(TUid, const TTime &, TBool &, CDriveData *)
voidLanguageChangedL(TBool &)
voidListImplementationsL(TUid, RImplDataArray &)
CRegistryData *NewL(RFs &)
CRegistryData *NewL(RFs &, TInt, TInt)
voidRemoveFromIndexL(CDllData *)
voidSetDiscoveryFlagL(const TDriveUnit &)
TInt SetEnabledState(TUid, TBool)
voidSetImplUpgradeCallBack(const TCallBackWithArg &)
voidTemporaryUninstallL(const TDriveUnit &)
voidUndoTemporaryUninstallL(const TDriveUnit &)
voidUpdateDllDataL(const TDriveUnit &, TInt, CDllData *)
Private Member Functions
CRegistryData(RFs &, TInt, TInt)
voidAddImplDataL(CDriveData *)
voidConstructL()
voidDeleteDllL(CDllData *)
voidDriveChanged(const TDriveUnit &, TBool)
voidFilterForLatestLegitimateImplL(TImplContainerArray &, CImplementationData *, TInsertImplMode &, TInt &, TBool &, TBool)
TInt FindImplementation(const TUid, const TUid, CImplementationData *&)
TInt IndexedFind(TUid)
voidInsertImplInIndexesL(TInsertImplMode, TInt, TInterfaceIndex &, TInt, CImplementationData *, TBool)
TInt InsertImplIntoImplIndex(CImplementationData *)
TBool MatchOnDrive(const CRegistryData::CDriveData &, const CRegistryData::CDriveData &)
TBool RemoveImplByAddrFromImplIndex(CImplementationData *)
voidRemoveImplFromImplIndexCleanUp(TAny *)
voidResetTInterfaceIndex(TAny *)
CImplementationData *SelectDuplicatedImpl(const CImplementationData *, const CImplementationData *)
CImplementationData *SelectPreferredImplL(CImplementationData *, CImplementationData *, TBool &, TBool)
voidValidateRegistryL()
Inherited Functions
CBase::CBase()
CBase::Delete(CBase *)
CBase::Extension_(TUint,TAny *&,TAny *)
CBase::operator new(TUint)
CBase::operator new(TUint,TAny *)
CBase::operator new(TUint,TLeave)
CBase::operator new(TUint,TLeave,TUint)
CBase::operator new(TUint,TUint)
CBase::~CBase()
Public Member Enumerations
enumTInsertImplMode { EInsertImplUndefinedMode, EInsertImplAsNewcomerOfInterface, EInsertImplAsUpgradeOfExistingImpl, EInsertImplAsUnusedImpl }
Public Member Type Definitions
typedef CRegistryData::CImplementationData * CImplementationDataPtr
typedef RArray< CImplementationDataPtr > RImplDataArray
Private Member Type Definitions
typedefstruct CRegistryData::TImplStruct TImplContainer
typedef RArray< TImplContainer > TImplContainerArray
typedefstruct CRegistryData::TInterfaceStruct TInterfaceIndex
typedef RPointerArray< CDriveData > TRegistration
Public Attributes
CEComCachedDriveInfo *iCachedDriveInfo
TDriveNumber iSystemDrive
Private Attributes
TBool iCurrentlyDiscovering
RFs &iFs
RPointerArray< CImplementationData >iImplIndex
TCallBackWithArg iImplUpgradeCallBack
RArray< TInterfaceIndex >iInterfaceImplIndex
TBool iLanguageChanged
TRegistration *iRegistrations
TInt iRemovedDrives

Constructor & Destructor Documentation

CRegistryData(RFs &, TInt, TInt)

CRegistryData(RFs &aFs,
TIntaInterfaceImplIndexGranularity,
TIntaImplIndexGranularity
)[private, explicit]

Parameters

RFs & aFsA handle to a connected file server.
TInt aInterfaceImplIndexGranularity
TInt aImplIndexGranularity

~CRegistryData()

~CRegistryData()[virtual]

Member Functions Documentation

AddDllDataL(const TDriveUnit &, TInt, CDllData *)

voidAddDllDataL(const TDriveUnit &aDrive,
TIntaFoundDriveIndex,
CDllData *aDllData
)
Adds data on a specific dll to the registry. The data to be added is parsed by CRegistryParser.
leave
KErrNoMemory If the item could not be appended to the registry
leave
KEComErrDriveNotFound If aDrive is not a valid drive
Pre-condition
This object is fully constructed and there is also a valid drive entry in the registry for aDrive
Post-condition
The new data is added to the registry

Parameters

const TDriveUnit & aDriveThe drive the registry data has been found on
TInt aFoundDriveIndexThe index of the registry data for the drive the interface implementation collection data has been found on.
CDllData * aDllDataThe dll data to add. CRegistryData takes ownership of this object so it should not be on the CleanupStack.

AddImplDataL(CDriveData *)

voidAddImplDataL(CDriveData *aDriveData)[private]
This method inserts implementations into the index
Pre-condition
This object is fully constructed.
Post-condition
all implemementations found, have been inserted into the index.

Parameters

CDriveData * aDriveDataDrive data in which we are searching the implementations

ConstructL()

voidConstructL()[private]
Completes the safe construction of the CRegistryData object.
leave
KErrNoMemory.
Pre-condition
This object is constructed
Post-condition
This object is fully initialized

DeleteDllL(CDllData *)

voidDeleteDllL(CDllData *aDllData)const [private]
This method removes all implementations of This Dll from the iInterfaceImplIndex, then delete this Dll from its parent Dll list.
Pre-condition
CRegistrar is fully constructed

Parameters

CDllData * aDllDatathe Dll to be cleaned.

DiscoveriesBeginning()

voidDiscoveriesBeginning()const
The cue that newly discovered Dlls are about to be registered, and, therefore, the registry index will be out of date until DiscoveriesCompleteL is called.
Pre-condition
CRegistrar is fully constructed
Post-condition
iCurrentlyDiscovering is set and the index list is cleared.

DiscoveriesCompleteL(TBool, TPluginProcessingTypeIdentifier, TBool &)

voidDiscoveriesCompleteL(TBoolaSuccessful,
TPluginProcessingTypeIdentifieraProcessingType,
TBool &aHasRegistryChanged
)
The cue to rebuild the registry indexes
leave
KErrNoMemory
CStore
Pre-condition
CRegistrar is fully constructed
Post-condition
The internal access indexes have been rebuilt

Parameters

TBool aSuccessfulIndicates whether discovery completed fully or not
TPluginProcessingTypeIdentifier aProcessingTypeindicates the type of processing for plugins for ensuring that plugins are not processed multiple times during start-up phase
TBool & aHasRegistryChangedThe flag to indicate whether registry data has been changed

DriveChanged(const TDriveUnit &, TBool)

voidDriveChanged(const TDriveUnit &aDrive,
TBoolaDriveRemoved
)[private]

Store change in drive state - addition or removal

Update the staus of drives in the system
Pre-condition
CRegistry is fully constructed.
Post-condition
The state of the drive has been stored

Parameters

const TDriveUnit & aDriveThe drive that has changed
TBool aDriveRemovedIndicates whether a drive has been removed or added

FilterForLatestLegitimateImplL(TImplContainerArray &, CImplementationData *, TInsertImplMode &, TInt &, TBool &, TBool)

voidFilterForLatestLegitimateImplL(TImplContainerArray &aIdxArray,
CImplementationData *aNewImpl,
TInsertImplMode &aInsertMode,
TInt &aPosOfImplInArray,
TBool &aLigitimateImpl,
TBoolaCheckIsNeeded
)[private]
This functions checks if a given implementation already exists in the indexes. If it does exist, determine if the given implementation should replace the existing one or not.
Pre-condition
This object is fully constructed.
Post-condition
none

Parameters

TImplContainerArray & aIdxArrayThe container array of the interface to hold the implementation.
CImplementationData * aNewImplThe implementation to filter.
TInsertImplMode & aInsertModewhether aNewIMpl is a newcomer of the interface, or an update of an existing implementation, or a older version of an existing implementation.
TInt & aPosOfImplInArrayreturn the index of aNewImpl in aIdxArray,
TBool & aLigitimateImplFlag,indicating whether current implementation is secure
TBool aCheckIsNeeded

FindDriveL(const TDriveUnit &, CDriveData *&)

TInt FindDriveL(const TDriveUnit &aDrive,
CDriveData *&aDriveData
)const

Parameters

const TDriveUnit & aDrive
CDriveData *& aDriveData

FindImplementation(const TUid, const TUid, CImplementationData *&)

TInt FindImplementation(const TUidaImplUid,
const TUidaInterfaceUid,
CImplementationData *&aImplData
)const [private]

Finds the instance of CImplementationData for given impl uid and interface uid if known.

Parameters

const TUid aImplUidThe uid of the impl to find
const TUid aInterfaceUidThe uid of the interface associated with the impl to find or less than 0 if uid is unknown
CImplementationData *& aImplDataSet to the instance CImplementationData found in the index or if not found set to NULL. This argument is always overwritten.

GetImplementationDllInfoForClientL(const TClientRequest &, const TUid, const TUid, TEntry &, CImplementationInformation *&, TBool)

TInt GetImplementationDllInfoForClientL(const TClientRequest &aClientRequest,
const TUidaImplUid,
const TUidaInterfaceUid,
TEntry &aEntry,
CImplementationInformation *&aImplInfo,
TBoolaSecurityCheckNeeded
)const
Pre-condition
CRegistrar is fully constructed

Parameters

const TClientRequest & aClientRequestA client request
const TUid aImplUidThe Uid of the implementation for which info is required
const TUid aInterfaceUidThe uid of the interface associated with aImplUid to find or less than 0 if uid is unknown.
TEntry & aEntryOutput parameter which will contain the dll information
CImplementationInformation *& aImplInfoAn output parameter. If the call succeeds it will point to the found implementation information, NULL otherwise.
TBool aSecurityCheckNeededThe bool value to identify whether the security check is needed here. The default value is false.

GetImplementationDllInfoForServer(const TCapabilitySet &, const TUid, const TUid, TEntry &, CImplementationInformation *&, TBool &)

TInt GetImplementationDllInfoForServer(const TCapabilitySet &aCapabilitySet,
const TUidaImplUid,
const TUidaInterfaceUid,
TEntry &aEntry,
CImplementationInformation *&aImplInfo,
TBool &aIsOnRWDrive
)const
Pre-condition
CRegistrar is fully constructed

Parameters

const TCapabilitySet & aCapabilitySetA capability set
const TUid aImplUidThe Uid of the implementation for which info is required
const TUid aInterfaceUidThe uid of the interface associated with aImplUid to find or less than 0 if uid is unknown.
TEntry & aEntryOutput parameter which will contain the dll information
CImplementationInformation *& aImplInfoAn output parameter. If the call succeeds it will point to the found implementation information, NULL otherwise.
TBool & aIsOnRWDrivean output parameter. If the call is successful, this will be set to ETrue if the implementation is on RW drive. EFalse if the implementation is on ReadOnly drive.

HasLanguageChanged()

TBool HasLanguageChanged()const
Indicates whether the language downgrade path has changed. This means we need to call NearestLanguageFile again
Pre-condition
CRegistrar is fully constructed

IndexValid()

TBool IndexValid()const
Indicates whether the registry index is currently valid. The index will not be valid if discoveries are currently taking place. If the index is not currently valid then calls to ListImplementationsL() cannot be serviced.
Pre-condition
CRegistrar is fully constructed

IndexedFind(TUid)

TInt IndexedFind(TUidaInterfaceUid)const [private]
To find the index entry for aImplementationUid.
Pre-condition
This object is fully constructed

Parameters

TUid aInterfaceUid

InsertImplInIndexesL(TInsertImplMode, TInt, TInterfaceIndex &, TInt, CImplementationData *, TBool)

voidInsertImplInIndexesL(TInsertImplModeaInsertMode,
TIntaIfPosInInterfaceImplIndex,
TInterfaceIndex &aNewIfIndexEl,
TIntaImplPosInContainerArray,
CImplementationData *aNewImpl,
TBoolaLegitimateImpl
)[private]

Handle inserting a CImplementationData in iInterfaceImplIndex and iImplIndex.

leave
KErrNoMemory operation fails because the system is out of memory.
leave
KErrGeneral any non-specific programming error.
leave
KErrAlreadyExists the indexes already have an entry with the same Impl. UID and Interface UID.

Parameters

TInsertImplMode aInsertModeindicates whether the implementation is a newcover of the interface, or is an update of existing implementation or is an older version of an existing implementation.
TInt aIfPosInInterfaceImplIndexis the index of the interface in iInterfaceImplIndex.
TInterfaceIndex & aNewIfIndexElthe TInterfaceIndex object containing the implementation.
TInt aImplPosInContainerArrayis the index of the implementation in the iImpData member of aNewIfIndexEl.
CImplementationData * aNewImplthe implementation to add to the indexes.
TBool aLegitimateImplindicate if the implementation passed security check or not.

InsertImplIntoImplIndex(CImplementationData *)

TInt InsertImplIntoImplIndex(CImplementationData *aNewImpl)const [private]

Insert aNewImpl into iImplIndex.

This method inserts the entry aNewImpl into iImplIndex.

Pre-condition
aNewImpl is fully constructed.

Parameters

CImplementationData * aNewImplthe item to add to iImplIndex.

InsertIntoIndexL(CImplementationData *, TBool)

TBool InsertIntoIndexL(CImplementationData *aImplPtr,
TBoolaCheckIsNeeded
)
This method retrieves the data for security checks from the iInterfaceImplIndex
Pre-condition
This object is fully constructed.
Post-condition
aImplPtr has been checked and added to the index, or not, depending on the outcome of the checks.

Parameters

CImplementationData * aImplPtrThe new item to be checked
TBool aCheckIsNeededBoolean indicating, whether a filename check is needed

IsAnyDllRegisteredWithDriveL(const TDriveUnit &)

TBool IsAnyDllRegisteredWithDriveL(const TDriveUnit &aDrive)const
Find if any Dll is regsitered in the drive unit.
Pre-condition
CRegistry is fully constructed.
Post-condition
If any Dll is registered in the drive is returned if successfully.

Parameters

const TDriveUnit & aDriveThe identifier of the drive to find if any Dll is registered.

IsRegisteredWithDate(TUid, const TTime &, TBool &, CDriveData *)

TBool IsRegisteredWithDate(TUidaDllUid,
const TTime &aModified,
TBool &aUpdate,
CDriveData *aDriveData
)
Determine if the specified implementation grouping already registered, but needs an update.
Pre-condition
This object is fully constructed and there is also a valid drive entry in the registry for aDrive
Post-condition
The new data is added to the registry

Parameters

TUid aDllUidThe interface implementation collection data to add. CRegistryData takes ownership of this object so it should not be on the CleanupStack.
const TTime & aModifiedThe date of the last modification of the Interface Implementation Collection.
TBool & aUpdateAn output to indicate if the registry entry requires an update. (Only valid if the return is ETrue).
CDriveData * aDriveDataThe drive data used to find DLL.

LanguageChangedL(TBool &)

voidLanguageChangedL(TBool &aLanguageChanged)

This method checks whether the language downgrade path has been changed. If it is, save language downgrade path information and set related flag true.

Parameters

TBool & aLanguageChangedthe returned value to indicate language changed.

ListImplementationsL(TUid, RImplDataArray &)

voidListImplementationsL(TUidaInterfaceUid,
RImplDataArray &aImplementationData
)const

Lists the implementations given the interface UID. The filtered list is returned in the client provided RImplDataArray parameter.

Parameters

TUid aInterfaceUidThe Uid of the interface which the implementations should provide
RImplDataArray & aImplementationDataReturn value. The filtered list.

MatchOnDrive(const CRegistryData::CDriveData &, const CRegistryData::CDriveData &)

TBool MatchOnDrive(const CRegistryData::CDriveData &aIndexOne,
const CRegistryData::CDriveData &aIndexTwo
)[private, static]

Used by a TIdentityRelation to decide if two CDriveData match.

Parameters

const CRegistryData::CDriveData & aIndexOneThe first CDriveData to compare
const CRegistryData::CDriveData & aIndexTwoThe second CDriveData to compare

NewL(RFs &)

CRegistryData *NewL(RFs &aFs)[static]
Standardized safe construction which leaves nothing on the cleanup stack. This overload uses default granularities for the two indexes. These default values were found to provide reasonably good performance at the time of testing.
leave
KErrNoMemory.
Post-condition
CRegistryData is fully constructed, and initialized.

Parameters

RFs & aFsThe open file session.

NewL(RFs &, TInt, TInt)

CRegistryData *NewL(RFs &aFs,
TIntaInterfaceImplIndexGranularity,
TIntaImplIndexGranularity
)[static]
This overload is provided for ECom performance test to find the optimum granularity settings. CEComImplIndexPerfTestStandardized safe construction which leaves nothing on the cleanup stack. This overload is used by CEComImplIndexPerfTest which plots discovery time vs. granularity settings.
leave
KErrNoMemory.
Post-condition
CRegistryData is fully constructed, and initialized.

Parameters

RFs & aFsThe open file session.
TInt aInterfaceImplIndexGranularitygranularity of main index.
TInt aImplIndexGranularitygranularity of auxiliary index.

RemoveFromIndexL(CDllData *)

voidRemoveFromIndexL(CDllData *aDllData)const
This method takes removes all implementations of a plugin from the iInterfaceImplIndex
Pre-condition
This object is constructed
Post-condition
All implementations of the CDllData object, have been removed from the index

Parameters

CDllData * aDllDataReference to a fully constructed CDllData object

RemoveImplByAddrFromImplIndex(CImplementationData *)

TBool RemoveImplByAddrFromImplIndex(CImplementationData *aPtr)const [private]

Remove the pointer from iImplIndex based on the impl address

This method does a search by address and removes the specified entry from iImplIndex.

Parameters

CImplementationData * aPtris the entry to remove

RemoveImplFromImplIndexCleanUp(TAny *)

voidRemoveImplFromImplIndexCleanUp(TAny *aPtr)[private, static]

Used to restore the impIndex sanity in case of a leave

Parameters

TAny * aPtr

ResetTInterfaceIndex(TAny *)

voidResetTInterfaceIndex(TAny *aObject)[private, static]

Parameters

TAny * aObject

SelectDuplicatedImpl(const CImplementationData *, const CImplementationData *)

CImplementationData *SelectDuplicatedImpl(const CImplementationData *aImpl1,
const CImplementationData *aImpl2
)const [private]

This function helps FindImplementation() to decide which of two implementations with duplicated implementation UID to choose. The selection rules are: 1. ROM based plugins > non-ROM based. 2. Higher drive letter > lower drive letter 3. Lower I/F UID > Higher I/F UID (for backward compatibility reason)

Parameters

const CImplementationData * aImpl1- one of the two implementations to compare.
const CImplementationData * aImpl2- the other implementation to compare.

SelectPreferredImplL(CImplementationData *, CImplementationData *, TBool &, TBool)

CImplementationData *SelectPreferredImplL(CImplementationData *aOldImpl,
CImplementationData *aNewImpl,
TBool &aLigitimateImpl,
TBoolaCheckIsNeeded
)const [private]
Determines whether the new implmentation should be preferred over the existing implementation. Validates later version implementations from R/W drives.
Pre-condition
This object is fully constructed.

Parameters

CImplementationData * aOldImplThe array to append to
CImplementationData * aNewImplThe item to append
TBool & aLigitimateImplFlag, indicating whether current implementation is secure
TBool aCheckIsNeeded

SetDiscoveryFlagL(const TDriveUnit &)

voidSetDiscoveryFlagL(const TDriveUnit &aDriveUnit)

Parameters

const TDriveUnit & aDriveUnit

SetEnabledState(TUid, TBool)

TInt SetEnabledState(TUidaImplementationUid,
TBoolaState
)
Enables or disables the specified interface implementation within the registry.
Pre-condition
CRegistry is fully constructed,
Post-condition
The implementation is now enabled or disabled as described by aState.

Parameters

TUid aImplementationUidThe interface implementation to change.
TBool aStateETrue to enable the implementation, EFalse to disable it

SetImplUpgradeCallBack(const TCallBackWithArg &)

voidSetImplUpgradeCallBack(const TCallBackWithArg &aCallBack)

setter If need to unset the callback, use a TCallBackWithArg constructed with no arguments.

Parameters

const TCallBackWithArg & aCallBack

TemporaryUninstallL(const TDriveUnit &)

voidTemporaryUninstallL(const TDriveUnit &aDrive)
Temporarily uninstalls the interface implementation groups upon the specified drive. (ie this can be undone later).
Pre-condition
CRegistry is fully constructed
Post-condition
The registered implementation groupings stored upon the specified drive are no longer available for use.

Parameters

const TDriveUnit & aDriveThe identifier of the drive to uninstall.

UndoTemporaryUninstallL(const TDriveUnit &)

voidUndoTemporaryUninstallL(const TDriveUnit &aDrive)
Undoes a temporary uninstall of the interface implementation groups upon the specified drive. (ie this can be undone later).
leave
KErrNoMemory, KErrReinstallFailed.
Pre-condition
CRegistry is fully constructed
Post-condition
The registered implementation groupings stored upon the specified drive are again made available for use.

Parameters

const TDriveUnit & aDriveThe identifier of the drive to reinstate.

UpdateDllDataL(const TDriveUnit &, TInt, CDllData *)

voidUpdateDllDataL(const TDriveUnit &aDrive,
TIntaFoundDriveIndex,
CDllData *aDllData
)
Updates the data for a dll in the registry.
leave
KErrNoMemory If the indexes cannot be rebuilt
Pre-condition
This object is fully constructed
Post-condition
The dll data is updated in the registry

Parameters

const TDriveUnit & aDrive
TInt aFoundDriveIndexThe index of the registry data for the drive the interface implementation collection data has been found on.
CDllData * aDllDataThe updated interface implementation collection data. CRegistryData takes ownership of this object so it should not be on the CleanupStack.

ValidateRegistryL()

voidValidateRegistryL()[private]
Checks each entry in the registry to ensure that both the RSC file and the corresponding dll exist. If not the dll branch is removed from the tree. If a drive branch is found which contains no dlls it is also removed.
Pre-condition
This object is fully constructed.
Post-condition
Any out of date registry entries are removed from the tree.

Member Enumerations Documentation

Enum TInsertImplMode

whether the implementation to be added to the registry data is a newcomer, or upgrade of an existing implementation, or downgrade of an existing implementation.

Enumerators

EInsertImplUndefinedMode
EInsertImplAsNewcomerOfInterface
EInsertImplAsUpgradeOfExistingImpl
EInsertImplAsUnusedImpl

Member Type Definitions Documentation

Typedef CImplementationDataPtr

typedef CRegistryData::CImplementationData *CImplementationDataPtr

Typedef RImplDataArray

typedef RArray< CImplementationDataPtr >RImplDataArray

Typedef TImplContainer

typedef struct CRegistryData::TImplStructTImplContainer[private]

Implementation structure containing the current in use implementation and a list of unused implementations with the same uid held in the registry tree. The unused list is used to allow efficient rollback to previous impl in the event that the current impl is removed.

Typedef TImplContainerArray

typedef RArray< TImplContainer >TImplContainerArray[private]

Typedef TInterfaceIndex

typedef struct CRegistryData::TInterfaceStructTInterfaceIndex[private]

Interface used by all implementation index

Typedef TRegistration

typedef RPointerArray< CDriveData >TRegistration[private]

Member Data Documentation

CEComCachedDriveInfo * iCachedDriveInfo

CEComCachedDriveInfo *iCachedDriveInfo

cached info on drivelist

TBool iCurrentlyDiscovering

TBool iCurrentlyDiscovering[private]

The flag to indicate that we are in the middle of discoveries and therefore the index list is probably out of date

RFs & iFs

RFs &iFs[private]

A reference to a connected file server instance

RPointerArray< CImplementationData > iImplIndex

RPointerArray< CImplementationData >iImplIndex[private]

Index of all implementations available to clients sorted by Implementation UID. Majority of clients do not specify the interface UID in their create requests. Thus ECOM needs this auxiliary index. Note that if multiple entries have the same Impl. UID, they are ordered by the interface UID.

TCallBackWithArg iImplUpgradeCallBack

TCallBackWithArg iImplUpgradeCallBack[private]

RArray< TInterfaceIndex > iInterfaceImplIndex

RArray< TInterfaceIndex >iInterfaceImplIndex[private]

The index of all registered implementations sorted by interface UID.

TBool iLanguageChanged

TBool iLanguageChanged[private]

A boolean, indicating if the language downgrade path has changed

TRegistration * iRegistrations

TRegistration *iRegistrations[private]

The entire registration data

TInt iRemovedDrives

TInt iRemovedDrives[private]

Bitmap indicating any drives removed

TDriveNumber iSystemDrive

TDriveNumber iSystemDrive

System Drive cache to allow access by CEComServer