// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Hardware Configuration Respoitory Platform Independent Layer (PIL)

//

// -- INCLUDES ----------------------------------------------------------------

#include "hcr_debug.h"

#include <e32def.h>

#include <e32err.h>

#include <e32des8.h>

#include <e32cmn.h>

#include <nkern/nkern.h>

#include <kernel/kernel.h>

#include <e32rom.h>

#include <plat_priv.h>

#include <kernel/kernboot.h>

#include "hcr_hai.h"

#include "hcr_pil.h"

// -- GLOBALS -----------------------------------------------------------------

GLDEF_C HCR::HCRInternal gHCR;

#ifdef HCR_TRACE

GLDEF_C TBuf<81> gTraceBuffer;

#endif

// -- Local functions prototypes

/**

Retrive Repository file address stored in the iHcrFileAddress field of ROM Image header.

If this filed is zero or it is equal with a special value then it keeps the original vaule of 

aRepos parameter and signals it with the retun value.

@param aRepos     		The reference to a repository variable    

@return	KErrNone 		if successful, the aRepos parameter references to the file in ROM Image.

        KErrNotFound 	if the ROM Image header contains zero or a special value as the repository file address

*/    

LOCAL_C TInt LocateCoreImgRepository(HCR::TRepository*& aRepos);

/**

This method transfer the value of aFileName to ROM Image conform file name string. 

Retrive the variant dependent ROM Root directory address.

Search the file in \sys\bin directory and if it doesn't exists there it try to find it in \sys\Data.

@param 	aRepos     			The reference to a repository variable.

				aFileName			  The name of the new repository file without path. '\0' terminated c-style string.

@return	KErrNone 			if successful

        KErrNotFound 		if file not found in \sys\bin or \sys\Data

*/    

LOCAL_C TInt SearchCoreImgRepository(HCR::TRepository* & aRepos, const TText * aFileName);

/**

Scanning a given directory for the given entry name. The entry name can be sub-directory or file.

@param 	aActDir     		Pointer to curretn directory in the ROM Image directory tree

		aFileName			File to be search

		aEntry				If the file found this referenced to proper directory entry

@return	 KErrNone		 			if the entry found

         KErrNotFound					if the entry not found

*/    

LOCAL_C TInt SearchEntryInTRomDir(const TRomDir* aActDir, const TPtrC aFileName, TRomEntry* &aEntry);

// -- WINS Specific ----------------------------------------------------------

#ifdef __WINS__

// Set to ensure Rom Hdr dependency does not break compilation in 

// LocateCoreImgRepository() at the end of this file.

// Undef incase it is set in MMP file, avoids compiler warning.

//

#undef HCRTEST_COREIMG_DONTUSE_ROMHDR

#define HCRTEST_COREIMG_DONTUSE_ROMHDR

#endif

// -- FUNCTIONS ---------------------------------------------------------------

/**

 Returns 1 when a1 > a2

 Returns -1 when a1 < a2

 Returns 0 when identical.

 */

TInt CompareSSettingIds(const HCR::TSettingId& a1, const HCR::SSettingId& a2)    

	{

    // HCR_FUNC("CompareSSettingIds");

    if (a1.iCat > a2.iCat)

        return (1); // HCR_TRACE_RETURN(1);

    if (a1.iCat < a2.iCat)

        return (-1); // HCR_TRACE_RETURN(-1);

    // Categories are the same at this point, check keys.

    if (a1.iKey > a2.iKey)

        return (1); // HCR_TRACE_RETURN(1);

    if (a1.iKey < a2.iKey)

        return (-1); // HCR_TRACE_RETURN(-1);

    // Both Categories and jeys are the same here.

    return (0); // HCR_TRACE_RETURN(0);

    }

#ifdef __EPOC32__

TBool ROMAddressIsInUnpagedSection(const TLinAddr address)

	{

    HCR_FUNC("ROMAddressIsInUnpagedSection");

	const TRomHeader& romHdr = Epoc::RomHeader();

	TLinAddr romBase = romHdr.iRomBase;

	HCR_TRACE1("--- address to check if in unpaged ROM section = 0x%8x", address);

	HCR_TRACE2("--- iRomSize (0x%8x), iPageableRomStart (0x%8x), ", romHdr.iRomSize, romHdr.iPageableRomStart);

	if ((address < romBase) || (romBase > romBase+romHdr.iRomSize))

		return EFalse;

	if (romHdr.iPageableRomStart == 0)

		return ETrue;

	if (address < romBase+romHdr.iPageableRomStart)

		return ETrue;

	return EFalse;

	}

#endif

TInt CompareByCategory(const HCR::TCategoryUid aCatId, const HCR::SSettingId& aSetId)    

    {

    //HCR_FUNC("CompareByCategory");

    if (aCatId > aSetId.iCat)

        return (1); // HCR_TRACE_RETURN(1);

    if (aCatId < aSetId.iCat)

        return (-1); // HCR_TRACE_RETURN(-1);

    // Both Categories and jeys are the same here.

    return (0); 

    }

/*

 * SafeArray TSa class object destructor. It delets the allocated in the heap

 * memory and set the instance pointer to NULL. See also TSa class definition

 * in hcr_pil.h.

 */

template<typename T>

    HCR::TSa<T>::~TSa()

    {

    delete[] iSa;

    iSa = NULL;

    }

/**

 * operator=() changes the memory ownership by   

 * reinitiazing SafeArray class object with the address to   

 * already allocated array.

 */

template<typename T>

   HCR::TSa<T>& HCR::TSa<T>::operator=(T* aP)

    {

    delete[] iSa;

    iSa = aP; 

    return (*this);

    }

// -- METHODS -----------------------------------------------------------------

//

// HCRInternal

HCR::HCRInternal::HCRInternal()

   : iStatus(EStatConstructed), iVariant(0), iVariantStore(0), iCoreImgStore(0), iOverrideStore(0)

    {

    HCR_FUNC("HCRInternal(Defualt)");

    }

HCR::HCRInternal::HCRInternal(HCR::MVariant* aVar)

   : iVariant(aVar), iVariantStore(0), iCoreImgStore(0), iOverrideStore(0)

    {

    HCR_FUNC("HCRInternal");

    }

HCR::HCRInternal::~HCRInternal()

    {

    HCR_FUNC("~HCRInternal");

    if (iVariant)

		{

		delete iVariant;

    	iVariant =0;

    	}

    if (iVariantStore)

		{

		delete iVariantStore;

    	iVariantStore =0;

    	}

    if (iCoreImgStore)

		{

		delete iCoreImgStore;

    	iCoreImgStore =0;

    	}

    if (iOverrideStore)

		{

		delete iOverrideStore;

    	iOverrideStore =0;

    	}

    }

TUint32 HCR::HCRInternal::GetStatus()

    {

    HCR_FUNC("GetStatus");

    return iStatus;

    }

TInt HCR::HCRInternal::Initialise()

    {

    HCR_FUNC("HCRInternal::Initialise");

    TAny* store = 0; 

    TInt err = 0;

	// Variant PSL object must exist before PIL initalised.

	if (iVariant == 0) {

 			err = KErrGeneral; goto failed; }

	// Inform the PSL that we are initialising, give them an opportunity to do

	// initialisation work too.

    err = iVariant->Initialise(); 

    if (err != KErrNone)

    	goto failed;

    iStatus = EStatVariantInitialised;

    // Ask the PSL for the address of the SRepositoryCompiled object. PSL 

    // can return KErrNotSupported & NULL if compiled repository not 

	// used/support by PSL.

    err = iVariant->GetCompiledRepositoryAddress(store);

    if (err == KErrNone)

        {

        if (store == 0) { // Programming error in PSL, ptr/rc mismatch

 			err = KErrArgument; goto failed; }

        iVariantStore = TRepositoryCompiled::New(reinterpret_cast<const HCR::SRepositoryCompiled *>(store));

        if (iVariantStore == 0) { 

			err = KErrNoMemory; goto failed; }

        }

    else if (err != KErrNotSupported)

    	goto failed;       

    // Ask the PSL if it wants the PIL not to search for the Core Image 

	// SRepositoryFile settings.

    iCoreImgStore = 0;

    if (!iVariant->IgnoreCoreImgRepository())

    	{

    	err = LocateCoreImgRepository(iCoreImgStore);

    	if (err == KErrNone)

     	   {

        	if (iCoreImgStore == 0) {

				err = KErrNoMemory; goto failed; }	

        	}

    	else if (err != KErrNotFound)

    		goto failed;

		}       

    // Ask the PSL for the address of the SRepositoryFile object. PSL 

    // can return KErrNotSupported & NULL if a local media based file 

	// repository is not used/support by PSL.  

    store = 0;

    err = iVariant->GetOverrideRepositoryAddress(store);

    if (err == KErrNone)

        {

        if (store == 0) { // Programming error in PSL, ptr/rc mismatch

 			err = KErrArgument; goto failed; }       

        iOverrideStore = TRepositoryFile::New(reinterpret_cast<const HCR::SRepositoryFile *>(store));

        if (iOverrideStore == 0) {

			err = KErrNoMemory; goto failed; }

        }

    else if (err != KErrNotSupported)

    	goto failed;       

	iStatus = EStatInitialised;

    // Sanity check here to ensure we have atleast one repository to use and run

    // sanity check on their contents to look for ordering issues and duplicates.

	HCR_TRACE3("=== HCR Ready: compiled:%x, coreimg:%x, override:%x", iVariantStore, iCoreImgStore, iOverrideStore);

    if ((iVariantStore == 0) && (iCoreImgStore == 0) && (iOverrideStore == 0)) {

 		err = KErrArgument; goto failed; }

#ifdef _DEBUG

	err = CheckIntegrity();

	if (err != KErrNone)

		goto failed;	

#endif

	iStatus = EStatReady;

	return KErrNone;

failed:

    iStatus = (iStatus & EStatMinorMask) | EStatFailed;

	HCR_TRACE_RETURN(err);

    }

TInt HCR::HCRInternal::SwitchRepository(const TText * aFileName, const TReposId aId)

	{

	HCR_FUNC("HCRInternal::SwitchRepository");

	TInt retVal = KErrNone;

	TRepository* store = NULL;

	if( aFileName != NULL)

		{

		retVal = SearchCoreImgRepository(store, aFileName);

		HCR_TRACE2("--- SearchCoreImgRepository()->%d (0x%08x)", retVal, retVal);

		}

	if( retVal == KErrNone )

		{

		switch(aId)

			{

			case ECoreRepos:

			    HCR_TRACE0("--- ECoreRepos");

				if( iCoreImgStore )

					{

					NKern::ThreadEnterCS();

					delete iCoreImgStore;

					NKern::ThreadLeaveCS();

					}

				iCoreImgStore = store;

				break;

			case EOverrideRepos:

			    HCR_TRACE0("--- EOverrideRepos");

				if( iOverrideStore )

    				{

	    			NKern::ThreadEnterCS();

					delete iOverrideStore;

					NKern::ThreadLeaveCS();

					}

				iOverrideStore = store;

				break;

			default:

			    HCR_TRACE0("--- default:");

				retVal = KErrNotSupported;

				break;		

			}

		}

	HCR_TRACE_RETURN(retVal);

    }

TInt HCR::HCRInternal::CheckIntegrity()

	{

	HCR_FUNC("HCRInternal::CheckIntegrity");

	TInt err = KErrNone;

	if (iVariantStore)

		{

		err = iVariantStore->CheckIntegrity();

		if (err != KErrNone)

			HCR_TRACEMSG_RETURN("HCR iVariantStore failed integrity check", err);

		}

	if (iCoreImgStore)

		{

		err = iCoreImgStore->CheckIntegrity();

		if (err != KErrNone)

			HCR_TRACEMSG_RETURN("HCR iCoreImgStore failed integrity check", err);

		}	

	if (iOverrideStore)

		{

		err = iOverrideStore->CheckIntegrity();

		if (err != KErrNone)

			HCR_TRACEMSG_RETURN("HCR iOverrideStore failed integrity check", err);

		}

	HCR_TRACE0("=== HCR Repository integrity checks PASSED!");

	return KErrNone;	

	}

TInt HCR::HCRInternal::FindSetting(const TSettingId& aId, TSettingType aType, 

        TSettingRef& aSetting)

    {

    HCR_FUNC("HCRInternal::FindSetting");

    TInt err = KErrNone;

    TBool found = EFalse;

    HCR_TRACE3("--- Repository state: %x, %x, %x", iOverrideStore, iCoreImgStore, iVariantStore);

    if (iOverrideStore && 

        ((err = iOverrideStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    __NK_ASSERT_DEBUG(err == KErrNotFound || err == KErrNone);

    if (!found &&

        iCoreImgStore &&

        ((err = iCoreImgStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    __NK_ASSERT_DEBUG(err == KErrNotFound || err == KErrNone);

    if (!found &&

        iVariantStore &&

        ((err = iVariantStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    __NK_ASSERT_DEBUG(err == KErrNotFound || err == KErrNone);

    HCR_TRACE3("--- Search results: %d, %d, %x", found, err, aSetting.iSet);

    if (!found)

        HCR_TRACE_RETURN(KErrNotFound);

    // aSetting should now point to the found setting

    __NK_ASSERT_DEBUG(aSetting.iSet != 0);

    // Setting found at this point in the function

    //

    TSettingType type=static_cast<TSettingType>(aSetting.iRep->GetType(aSetting)); 

    if (type & ~aType)

        HCR_TRACE_RETURN(KErrArgument); // Wrong setting type

    HCR_TRACE3("--- Setting found! ID: (%d,%d) Type: %d", aId.iCat, aId.iKey, type);

    return err;

    }

TInt HCR::HCRInternal::FindSettingWithType(const TSettingId& aId, TSettingType& aType, 

      TSettingRef& aSetting)

    {

    HCR_FUNC("HCRInternal::FindSettingWithType");

    TInt err = KErrNone;

    TBool found = EFalse;

    HCR_TRACE3("--- Repository state: %x, %x, %x", iOverrideStore, iCoreImgStore, iVariantStore);

    if (iOverrideStore && 

        ((err = iOverrideStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    __NK_ASSERT_DEBUG(err == KErrNotFound || err == KErrNone);

    if (!found &&

        iCoreImgStore &&

        ((err = iCoreImgStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    __NK_ASSERT_DEBUG(err == KErrNotFound || err == KErrNone);

    if (!found &&

        iVariantStore &&

        ((err = iVariantStore->FindSetting(aId, aSetting)) == KErrNone))

        found = ETrue;

    __NK_ASSERT_DEBUG(err == KErrNotFound || err == KErrNone);

    HCR_TRACE3("--- Search results: %d, %d, %x", found, err, aSetting.iSet);

    if (!found)

        {

        aType = ETypeUndefined;

        HCR_TRACE_RETURN(KErrNotFound);

        }

    // aSetting should now point to the found setting

    __NK_ASSERT_DEBUG(aSetting.iSet != 0);

    // Setting found at this point in the function

    //

    aType=static_cast<TSettingType>(aSetting.iRep->GetType(aSetting)); 

    HCR_TRACE3("--- Setting found! ID: (%d,%d) Type: %d", aId.iCat, aId.iKey, aType);

    return err;

    }

TInt HCR::HCRInternal::GetWordSettings(TInt aNum, const SSettingId aIds[], 

        TInt32 aValues[], TSettingType aTypes[], TInt aErrors[])

    {

    HCR_FUNC("++ HCRInternal::GetWordSettings");

    HCR_TRACE3("--- Repository state: %x, %x, %x", iOverrideStore, iCoreImgStore, iVariantStore);

    if(aNum <= 0 || aIds == NULL || aErrors == NULL)

        HCR_TRACE_RETURN(KErrArgument);

    TInt err = 0;

    //If the user only supplies a single setting then there is no reasons to 

    //continue with multiple searach and it should be limited by internal 

    //invocation of FindSettingWithType.

    if(aNum == 1)

        {

        TSettingRef sref(0,0);

        TSettingType* pTypes;

        //aTypes array is optional and user may not provided it for us. So we

        //need to be sure it's not a null pointer

        if(aTypes == NULL)

            {

            //If this is a null pointer then just create our own element and 

            //assign it to the pTypes pointer

            TSettingType types[1];

            pTypes = types;

            }

        else

            {

            //else we use the user supplied array

            pTypes = aTypes;

            }

        //Let's find this setting

        err = HCRSingleton->FindSettingWithType(aIds[0], *pTypes, sref);

        //and analyse the result of operation

        //If setting is not found or it's larger than 4 bytes then store this

        //error cause in the user error array 

        if(err == KErrNotFound || err == KErrArgument)

            {

            //Indicate the error for the element and set the value to 0

            aErrors[0] = err;

            aValues[0] = 0;

            return 0;

            }

        //fatal error here, nothing to do, just exit and return the error code

        else if(err == KErrNotReady || err != KErrNone)

            {

            HCR_TRACE_RETURN(err);

            }

        else //err == KErrNone

            {

            //Get the value of the setting

            err = sref.iRep->GetValue(sref, reinterpret_cast<UValueWord&>(aValues[0]));

            //The GetValue can only return either KErrArgument or KErrNone

            if(err == KErrArgument)

                {

                aErrors[0] = KErrArgument;

                aValues[0] = 0;

                return 0;

                }

            else //err == KErrNone

                {

                aErrors[0] = KErrNone;

                }

            }

        //This single setting was found so indicate it to the user

        return (1);

        }

    //Introducing a SafeArray of pointers to the settings, which is passed to ver- 

    //sion of GetWordSettings() method declared in TRepository, and implemented 

    //in TRepositoryCompiled and TRepositoryFile

    TSa<SSettingId*> ids;

    //SafeArray of pointers to the aValues user array elements 

    TSa<TInt32*> values;

    //SafeArray of pointers to the aErrors user array elements 

    TSa<TInt*> errors;

    //SafeArray of pointers to the aTypes user array elements

    TSa<TSettingType*> types;

    //Local replacement for the aTypes[] array if it's not provided by user

    TSa<TSettingType> typesHolder;

    //Allocate the arrays of pointers in the  heap

    ids = new SSettingId*[aNum];

    values = new TInt32*[aNum];

    errors = new TInt*[aNum];

    types  = new TSettingType*[aNum];

    //Check all arrays allocations

    if(!ids() || !values() || !errors() || !types())

        {

        //One of the allocation was unsuccessful 

        HCR_TRACE_RETURN(KErrNoMemory);

        }

    //If the user did not supply the aTypes array for us we need to create one 

    //for ourself

    if(aTypes == NULL)

        {

        typesHolder = new TSettingType[aNum];

        if(!typesHolder())

            HCR_TRACE_RETURN(KErrNoMemory);

        }

    //Ininialize newly created array of pointers to the user supplied settings 

    for (TInt index = 0; index < aNum; index++)

        {

        ids[index] = const_cast<SSettingId*>(&aIds[index]);

        values[index] = const_cast<TInt32*>(&aValues[index]);

        errors[index] = &aErrors[index];

        if(aTypes == NULL)

            types[index] = &typesHolder[index];

        else

            types[index] = &aTypes[index];

        }

    //nfCount represents a total number of settings which were not found in all

    //repositories

    TInt nfCount = aNum;

    //nfReposCount represents a number of settings "not found - nf" in the searched

    //repository

    TInt nfReposCount   = 0;

    //It represents a number of setting found in the repository

    TInt reposCount   = 0;

    //First step through the Override store and gather all settings we need.

    //In the end of this procedure we'll have number of settings not found here

    //and found settings data are copied to the user arrays.

    if (iOverrideStore)

        {

        //Call the sibling method from the TRepositoryFile object

        err = iOverrideStore->GetWordSettings(aNum, ids(),

                values(), types(), errors());

        //Analyse the err we've got 

        if(err != KErrNone && err != KErrNotFound)

            {

            HCR_TRACE_RETURN(err);

            }

        else if(err == KErrNone)

            {

            //Search for number of not found parameters

            for(TInt index = 0; index < aNum; index ++)

                {

                switch(*(errors[index]))

                    {

                    //The setting was found or it's found but the type is larger

                    //than 4 bytes then we just increase a counter of the found

                    //settings in the repository

                    case KErrNone:

                    case KErrArgument:

                        reposCount ++;

                        break;

                    //The setting was not found, then re-initialize all the 

                    //arrays of pointers with the pointer to this element. 

                    //nfReposCount depict the counter of not found element and

                    //index shows the intial element position.

                    //As nfReposCount is always less or equal to index then we

                    //can easily make reassignment as nfReposCoun element was

                    //already analysed. In the end the nfReposCount is increased.

                    case KErrNotFound:

                        ids[nfReposCount]        = ids[index];

                        values[nfReposCount]     = values[index];

                        types[nfReposCount]      = types[index];

                        errors[nfReposCount]     = errors[index];                  

                        nfReposCount ++;

                        break;

                    default:

                        //No any action is needed

                        break;

                    }

                }

            }

        else //err == KErrNotFound

            {

            //No settings were found in the repository

            //reposCount is zero intialized, so nothing to do here

            }

        //Update the global counter only if there are some settings were found,

        //otherwise it can be situation when we overwrite the nfCount with zero

        //when either no any setting presents or no settings were found in the

        //repository

        if(reposCount > 0)

            nfCount = nfReposCount;

        }

    //Go through core image and search for the rest of settings

    nfReposCount = 0;

    reposCount = 0;

    if (iCoreImgStore && nfCount > 0)

        {

        err = iCoreImgStore->GetWordSettings(nfCount, ids(),

                                                values(), types(), errors());

        if (err != KErrNone && err != KErrNotFound)

            {

            HCR_TRACE_RETURN(err);

            }

        else if(err == KErrNone)

            {

            //Search for number of errors

            for(TInt index = 0; index < nfCount; index ++)

                {

                switch(*(errors[index]))

                    {

                    //The setting was found or it's found but the type is larger

                    //than 4 bytes then we just increase a counter of the found

                    //settings in the repository

                    case KErrNone:

                    case KErrArgument:

                        reposCount ++;

                        break;

                    //The setting was not found, then re-initialize all the 

                    //arrays of pointers with the pointer to this element. 

                    //nfReposCount depict the counter of not found element and

                    //index shows the intial element position.

                    //As nfReposCount is always less or equal to index then we

                    //can easily make reassignment as nfReposCoun element was

                    //already analysed. In the end the nfReposCount is increased.

                    case KErrNotFound:

                        ids[nfReposCount]        = ids[index];

                        values[nfReposCount]     = values[index];

                        types[nfReposCount]      = types[index];

                        errors[nfReposCount]     = errors[index];                  

                        nfReposCount ++;

                        break;

                    default:

                        //No any action is needed

                        break;

                    }

                }

            }

        else //err == KErrNotFound 

            {

            //No settings were found in the repository

            //reposCount is zero intialized, so nothing to do here

            }

        //Update the global counter only if there are some settings were found,

        //otherwise it can be situation when we overwrite the nfCount with zero

        //when either no any setting presents or no settings were found in the

        //repository 

        if(reposCount > 0)

            nfCount = nfReposCount;

        }

    //let's go through the last Variant store

    nfReposCount = 0;

    reposCount = 0;

    if(iVariantStore && nfCount > 0)

        {

        err = iVariantStore->GetWordSettings(nfCount, ids(), values(), 

                types(), errors());

        if (err != KErrNone && err != KErrNotFound)

            {

            HCR_TRACE_RETURN(err);

            }

        else if(err == KErrNone)

            {

            //Search for number of errors

            for(TInt index = 0; index < nfCount; index ++)

                {

                switch(*(errors[index]))

                    {

                    //The setting was found or it's found but the type is larger

                    //than 4 bytes then we just increase a counter of the found

                    //settings in the repository

                    case KErrNone:

                    case KErrArgument:

                        reposCount ++;

                        break;

                    //The setting was not found, then re-initialize all the 

                    //arrays of pointers with the pointer to this element. 

                    //nfReposCount depict the counter of not found element and

                    //index shows the intial element position.

                    //As nfReposCount is always less or equal to index then we

                    //can easily make reassignment as nfReposCoun element was

                    //already analysed. In the end the nfReposCount is increased.

                    case KErrNotFound:

                        *values[nfReposCount]     = 0;

                        *types[nfReposCount]      = ETypeUndefined;

                        *errors[nfReposCount]     = KErrNotFound;

                        nfReposCount ++;

                        break;

                    default:

                        //No any action is needed

                        break;

                    }

                }

            }

        else //err == KErrNotFound

            {

            //No settings were found in the repository

            //reposCount is zero intialized, so nothing to do here

            }

        //Update the global counter only if there are some settings were found,

        //otherwise it can be situation when we overwrite the nfCount with zero

        //when either no any setting presents or no settings were found in the

        //repository

        if(reposCount > 0)

            nfCount = nfReposCount;

        }

    //Return the number of found elements

    return (aNum - nfCount);

    }

TInt HCR::HCRInternal::FindNumSettingsInCategory (TCategoryUid aCatUid)

    {

    HCR_FUNC("++ HCRInternal::FindNumSettingsInCategory");

    TInt err = 0;

    HCR_TRACE3("--- Repository state: %x, %x, %x", iOverrideStore, iCoreImgStore, iVariantStore);

    //First and last element index within category in the Override store

    TInt32 oLowIndex = 0;

    TInt32 oHighIndex = 0;

    TInt oCount = 0;

    //Find numOverride number of settings within the category in the OverrideStore 

    //repository

    if(iOverrideStore)

        {

        err = iOverrideStore->FindNumSettingsInCategory(aCatUid, 

                oLowIndex, oHighIndex);

        if(err == KErrNotFound)

            oCount = 0;

        else

            oCount = oHighIndex - oLowIndex + 1;

        //If CoreImg and Variant store are not activated so just return the

        //number of elements found in the Override store

        if(!iCoreImgStore && !iVariantStore)

            return oCount;

        }

    //First and last element index within category in the CoreImg store

    TInt32 cLowIndex = 0;

    TInt32 cHighIndex = 0;

    TInt32 cLength = 0;

    TInt   cCount = 0;

    //Temproary holder for the found element position

    TInt32 elementPos;

    //Temproary holder for the low index, which is used to decrease the scope

    //of search

    TInt32 lowIndex = oLowIndex;

    //Setting data holders

    SSettingId setId;

    TSettingRef setRef;

    if(iCoreImgStore)

        {

        //Find numCoreImg number of settings within the category in the CoreImg re-

        //pository

        err = iCoreImgStore->FindNumSettingsInCategory(aCatUid, 

                cLowIndex, cHighIndex);

        if(err == KErrNotFound)

            cLength = 0;

        else

            //Calculate the number of elements within category, in CoreImg store

            cLength = cHighIndex - cLowIndex + 1;

        if(oCount > 0)

            {

            //Find all elemnts from CoreImg store which are not redefined in the 

            //Override store. When element is not found in the Override store 

            //then cCount is increased.

            for(TInt element = 0; element < cLength; element ++)

                {

                //Find element in the repository by its index

                iCoreImgStore->GetSettingRef(cLowIndex + element, setRef);

                //and get its id

                iCoreImgStore->GetId(setRef, setId);

                //Check either this element is already redefined in the Override

                //store

                err = iOverrideStore->FindSetting( setId, setRef, 

                        elementPos, lowIndex, oHighIndex);

                if(err == KErrNone)

                    {

                    //if the element is found in the Override store, then store the posi-

                    //tion of this element in lowIndex, to narrow next search procedure

                    lowIndex = elementPos;

                    }

                else //err == KErrNotFound

                    {

                    //if element is not found then it means it's not redefined in the 

                    //Override store and this element must be counted in the total number

                    //of elemnts in all stores

                    cCount ++;

                    //FindSetting can only return KErrNotFound, let's assert 

                    //we've only got KErrNotFound

                    __NK_ASSERT_DEBUG(err == KErrNotFound);

                    }

                }

            }

        else

            {

            cCount = cLength;

            }

        }

    //First and last element index within giving category in the Variant store

    TInt32 vLowIndex  = 0;

    TInt32 vHighIndex = 0;

    TInt32 vLength = 0;

    TInt vCount = 0;

    if(iVariantStore)

        {

        //Find numVariant number of settings within the category in the VariantStore

        //repository

        err = iVariantStore->FindNumSettingsInCategory(aCatUid, vLowIndex, 

                vHighIndex);

        //Analyze returned error code

        if(err == KErrNotFound)

            vLength = 0;

        else

            //Calculate the number of elements within category, in CoreImg store

            vLength = vHighIndex - vLowIndex + 1;

        if(oCount > 0 || cCount >0)

            {

            //Find all elemnts from Variant store which are not redefined either in the