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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Implementation of MetaDatabase interface functions for CommsDat

// 

//

/**

 @file 

 @publishedAll

 @released

*/

#include <commsdattypesv1_1.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <commsdat_partner.h>

#endif

#include "CommsDatInternalDefs.h"

#include "CommsDatValidator.h"

#include "CommsDatMapper.h"

#include "MetaDatabaseVisitor.h"

#include <commsdatutils.h>

#include <comms-infras/commsdatschema.h>

using namespace CommsDat;

using namespace CommsDatInternal;

using namespace Meta;

/*  

MMetaDatabase 

Implementation of main high-level algorithm for each MMetaDatabase call.

Detailed activity left to visitors for each field that needs to be handled.

*/

EXPORT_C MMetaDatabase::MMetaDatabase()

/**

 * Protected and explicit constructor - nothing to construct

 */

    {

    }

EXPORT_C MMetaDatabase::~MMetaDatabase()

/**

 * Virtual destructor - nothing to destroy

 */

    {

    }

TBool CompareColumn(const TUint32& aFirst, const TUint32& aSecond)

// Utility for RArray Find

    {

    TBool ret =  ((aFirst & KCDMaskShowType) == (aSecond & KCDMaskShowType));

    return ret;

    }

//

EXPORT_C void MMetaDatabase::LoadL(CMDBSession& aSession)

/**

 * Loads each member of the MMetaDatabase object from the database.

 * Will (delete and) overwrite any data already in the container.

 **/

    {   

    CMDBSessionImpl* session = aSession.iMDBSessionImpl;

    // no need for a transaction for read, but do want the write lock.

   // TBool ownTransaction = session->MaybeOpenTransactionL();

    TAny* mem[KMMetaDBVisitorMaxSize];

    TMetaVTableIterator attribIter(this);

    SVDataTableEntry const* entry = NULL;

    TMDBVisitorBase* metaDBVisitor = NULL;

    CMDBElement* thisElement = static_cast<CMDBElement*>(this);

    __FLOG_STATIC1(KLogComponent, KCDInfoLog, _L("MMetaDatabase::LoadL() called for Element %08x..."), thisElement->ElementId());

    TInt err(KErrNotFound);

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    CCDMapper* mapper = CCDMapper::MaybeCreateMapperLC(*thisElement,*aSession.iMDBSessionImpl,ELoad);

#else

    CCDMapper* mapper = NULL;

#endif

    TUint32& elementId = *thisElement->Data();

    if ((elementId & KCDMaskShowRecordType) != 0) 

        {

        // Table id has been set

        err = session->LoadElementAttributesL(elementId);

        }        

    if (err == KErrNotFound)

        {

        if (mapper ||                                     //we have a mapper object  

            ! CommsDatSchema::IsNode(elementId)        || // Could be a generic record trying to load by name, so let it carry on.

            CommsDatSchema::IsGenericRecord(elementId)   )// let it find the template record

            {

	        err = KErrNone;	

	        }

        }

    if (err == KErrNone)

        {

        if (!mapper &&

            (CommsDatSchema::IsRecord(elementId) ) && 

            !CommsDatSchema::IsTemplate(elementId) 

            && !CommsDatSchema::IsGenericRecord(elementId))

            {

            // This section gets template field where appropriate and ensures minimal call to find in database

            RArray<TUint32> recordIds;

            CleanupClosePushL(recordIds);

            RArray<TUint32> templateIds;

            CleanupClosePushL(templateIds);

            // Find all entries in the record

            TUint32 mask = KCDMaskShowRecordType | KCDMaskShowRecordId | session->GetReadAttributeMask() | KCDUtilityFlag;

            TUint32 id = elementId & KCDMaskHideAttrAndRes;

            TInt err = session->StorageL()->FindL(id, mask, recordIds);  

            if (recordIds.Count())

                {

                // Find all entries for the template

                mask = (KCDMaskShowRecordType | KCDMaskShowRecordId | session->GetReadAttributeMask() | KCDUtilityFlag) & ~ECDHidden;

                session->StorageL()->FindL(id & ~KCDMaskShowRecordId, mask, templateIds); // there might not be a template don't need to check err

                TInt loc(0);

                TInt fieldId(0);

                while ( (err == KErrNone || err == KErrNotFound)  &&  (entry = attribIter++) != NULL )

                    {

                    metaDBVisitor = static_cast<TMDBVisitorBase*>(entry->iMetaNewL(mem,GetAttribPtr(entry->iOffset))); // target

                    if (metaDBVisitor) // might be deprecated

                    	{

                        metaDBVisitor->SetOwner(thisElement);

                        // can optimise further by not doing array finds in this way

                        loc = recordIds.Find(metaDBVisitor->ElementId(), CompareColumn);

                        if (loc != KErrNotFound)

                            {

                            metaDBVisitor->SetElementId(recordIds[loc]);

                            // know the value is there so just get it

                            err = metaDBVisitor->GetL(session);

                            if (err != KErrNone)

                                {

                                // oh dear, should have found this.  Something's gone horribly wrong

                                __FLOG_STATIC1(KLogComponent, KCDErrLog, _L("MMetaDatabase::LoadL() VisitorGetL failed unexpectedly for Element %08x with err %d"), metaDBVisitor->ElementId());

                                User::Leave(err);

                                }

                            recordIds.Remove(loc);

                            }

                        else if (templateIds.Count())

                            {

                            loc = templateIds.Find(metaDBVisitor->ElementId(), CompareColumn);

                            if (loc != KErrNotFound)

                                {

                                // get the template value instead

                                fieldId = metaDBVisitor->ElementId();

                                metaDBVisitor->SetElementId(templateIds[loc]);

                                err =metaDBVisitor->GetL(session);

                                if (err != KErrNone)

                                    {

                                    // Should have found this too  Something else has gone horribly wrong 

                                    __FLOG_STATIC1(KLogComponent, KCDErrLog, _L("MMetaDatabase::LoadL() VisitorGetL failed unexpectedly for Element %08x with err %d"), metaDBVisitor->ElementId());

                                    metaDBVisitor->SetElementId(fieldId);

                                    User::Leave(err);

                                    }

                                metaDBVisitor->SetElementId(fieldId);

                                metaDBVisitor->FieldLoaded();

                                templateIds.Remove(loc);

                                }

                            }

                        if (loc == KErrNotFound)

                            {

                            metaDBVisitor->ClearValue();

                            }

                        }

                    }

                }

            CleanupStack::PopAndDestroy(&templateIds);

            CleanupStack::PopAndDestroy(&recordIds);

            }

        else

            {

            DoLoadL(session, thisElement, mapper, err, thisElement->ElementId() & KCDMaskShowRecordId, thisElement->Attributes());

            /* This is a work around solution for the following case:

             * There is a table with legacy links. [IAP table, BearerType and Bearer fields in it]. With the

             * new CommsDat the Bearer field value is the fully resolved TMDBElementId of the linked record.

             * BUT there is a lot of code which expects this value to be only a record number (as it is 

             * originally in the config file) after the reading it.

             * Even worse there is code which tries to read this field via a CMDBField<TInt> while this field is

             * from now on a CMDBField<someLink>. So if somebody tries to read an integer field we have to check

             * whether is it a legacy link or not. If it is, then we have to do conversion on the value to contain

             * only the record number of the linked record and not the TMDBElementId.

             */

            if (CommsDatSchema::IsColumn(thisElement->ElementId() | KCDMaskShowRecordId) && 

             	(thisElement->Type() ==EInt || thisElement->Type()==EUint32))

             	{

             	CommsDatSchema::ChangeLegacyLinkFieldValues(thisElement);

             	}

            }

        /***********************************************************/

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

        // Now load any mapped elements too 

        if (!mapper)

            {

            mapper = CCDMapper::MaybeCreateMapperLC(*thisElement,*aSession.iMDBSessionImpl,ELoad);

            }

	    if ( mapper )

            {   

            DoLoadL(session, mapper, NULL, err, thisElement->ElementId() & KCDMaskShowRecordId, thisElement->Attributes(), ETrue);

            mapper->MapResultsL();

            /* This is a work around solution for the following case:

             * There is a table with legacy links. [IAP table, BearerType and Bearer fields in it]. With the

             * new CommsDat the Bearer field value is the fully resolved TMDBElementId of the linked record.

             * BUT there is a lot of code which expects this value to be only a record number (as it is 

             * originally in the config file) after the reading it.

             * Even worse there is code which tries to read this field via a CMDBField<TInt> while this field is

             * from now on a CMDBField<someLink>. So if somebody tries to read an integer field we have to check

             * whether is it a legacy link or not. If it is, then we have to do conversion on the value to contain

             * only the record number of the linked record and not the TMDBElementId.

             */

            if (CommsDatSchema::IsColumn(thisElement->ElementId() | KCDMaskShowRecordId) && 

             	(thisElement->Type() ==EInt || thisElement->Type()==EUint32))

             	{

             	CommsDatSchema::ChangeLegacyLinkFieldValues(thisElement);

             	}

            CleanupStack::PopAndDestroy(mapper);                

            }

#endif

        }

        else

        {

        // Nothing at all found  or some other error

        __FLOG_STATIC1(KLogComponent, KCDErrLog, _L("MMetaDatabase::LoadL() failed for Element %08x as this node was not found in the database."), thisElement->ElementId() );

        User::Leave(err);

        }

    }    

/*

 This DoLoadL is called from the LoadL method if the client tries to load a field and not a record.

*/

void MMetaDatabase::DoLoadL(CMDBSessionImpl* aSession, 

                            CMDBElement* aElement, 

                            CMDBElement* aMapper, 

                            TInt &aErr, 

                            TMDBElementId aRecordId,

                            TMDBElementId aAttributes,

                            TBool isTheLoadForMapper)

    {

    TAny* mem[KMMetaDBVisitorMaxSize];

    TMetaVTableIterator attribIter(aElement);

    SVDataTableEntry const* entry = 0;

    TMDBVisitorBase* metaDBVisitor = 0;

    CCDMapper* mapper = static_cast<CCDMapper*>(aMapper);

    TBool loadTemplateField = !CommsDatSchema::IsTable(aElement->ElementId());

    // Apply Load function to each unmapped entry

    while ( (aErr == KErrNone  ||  aErr == KErrNotFound) &&  (entry = attribIter++) != NULL)

        {

        metaDBVisitor = static_cast<TMDBVisitorBase*>(entry->iMetaNewL(mem,aElement->GetAttribPtr(entry->iOffset))); // target

        if (metaDBVisitor) // might be deprecated

            {

            metaDBVisitor->SetOwner(aElement);

            if ( ! mapper  || ! mapper->Mapped(metaDBVisitor->ElementId()) )

                {

                aErr = metaDBVisitor->LoadL(aSession, aRecordId, aAttributes);

                if ( aErr == KErrNotFound && loadTemplateField )

                    {

                    if (!aSession->IsSetAttributeMask(ECDHidden))  

                        {

                        aSession->SetAttributeMask(ECDHidden);

                        aErr = metaDBVisitor->LoadL(aSession, KCDDefaultRecord, ECDHidden);

                        aSession->ClearAttributeMask(ECDHidden); //need to cleanup if LoadL leaves

                        }

                    else

                        {

                        aErr = metaDBVisitor->LoadL(aSession, KCDDefaultRecord, ECDHidden);

                        }

                    if (KCDInitialRecordId <= aRecordId && 

                		KErrNone == aErr)

                		{

                		/* This means that the given field is read from the template record and the recordId of the

                		 * record in question (on which the FindL is called) is not a template record as the aRecordId

                		 * is not 0. This means that all of the flags should be removed from the elementId of the

                		 * metaDBVisitor (hidden, modified) and the value should be given back to the client. In this 

                		 * case the user gets the value from the template record, the TMDBElementId of the given field 

                		 * is set so as the value would have been read from the record itself. When StoreL will be called

                		 * on this record and this field is not changed it won't be stored once again in this record but

                		 * remains only in the template record. Of course if the user changes the value of this field it

                		 * will be stored into the given reocrd as the changed flag will be set.

                		 */

                		metaDBVisitor->ResetElementId(aRecordId);

                		}

                    //We don't do this branch for mappers because it can just mix up the logic

                    //implemented in the PostMapping functions...

                    else if (KErrNone != aErr &&

                    		!isTheLoadForMapper)

                    	{

                    	/* The reading of the field is still erronous, and this means at this stage that it

                    	 * simply doesn't exist in the given record. What is important in this case is that

                    	 * the value of the given field should be set to NULL, because if it's a container

                    	 * re-use case, meaning that the container is re-used for reading from a record set

                    	 * for example, this is the way we can indicate that the given field is not existing

                    	 * in the record, nor in the template record...

                    	 * This is the 9.5 propagation of the INC123203 

                    	 */

                    	metaDBVisitor->ResetElementId(aRecordId);

                    	metaDBVisitor->ClearValue();

                    	}

                    }

                }

            }

        }

    if (aErr == KErrNotFound)

        {

        if ( aElement->ElementId() &&

             !CommsDatSchema::IsNode(aElement->ElementId()) )

         //When the client tried to load a field explicitly and the given one cant be found we leave.

            {

            User::Leave(aErr);

            }

        else

            { 

            aErr = KErrNone;

            }

        }

    }

/*

 This DoLoadL is called from the FindL method.

*/

void MMetaDatabase::DoLoadL(CMDBSessionImpl* aSession, 

                            CMDBElement* aElement, 

                            CMDBElement* aMapper,

                            TInt &aErr, 

                            TMDBElementId aRecordId,

                            TMDBElementId aAttributes,

                            RArray<TUint32>& aMatches,

                            TBool isTheLoadForMapper)

    {

    TAny* mem[KMMetaDBVisitorMaxSize];

    TMetaVTableIterator attribIter(aElement);

    SVDataTableEntry const* entry = 0;

    TMDBVisitorBase* metaDBVisitor = 0;

    CCDMapper* mapper = static_cast<CCDMapper*>(aMapper);

    TBool loadTemplateField = !CommsDatSchema::IsTable(aElement->ElementId());

    // Apply Load function to each unmapped entry

    while ( (aErr == KErrNone  ||  aErr == KErrNotFound) &&  (entry = attribIter++) != NULL)

        {

        metaDBVisitor = static_cast<TMDBVisitorBase*>(entry->iMetaNewL(mem,aElement->GetAttribPtr(entry->iOffset))); // target

        if (metaDBVisitor) // might be deprecated

            {

            metaDBVisitor->SetOwner(aElement);

            if ( ! mapper  || ! mapper->Mapped(metaDBVisitor->ElementId()) )

                {

                aErr = metaDBVisitor->LoadL(aSession, aRecordId, aAttributes, aMatches);

                if ( aErr == KErrNotFound && loadTemplateField )

                    {

                    if (!aSession->IsSetAttributeMask(ECDHidden))  

                        {

                        aSession->SetAttributeMask(ECDHidden);

                        aErr = metaDBVisitor->LoadL(aSession, KCDDefaultRecord, ECDHidden);

                        aSession->ClearAttributeMask(ECDHidden); //need to cleanup if LoadL leaves

                        }

                    else

                        {

                        aErr = metaDBVisitor->LoadL(aSession, KCDDefaultRecord, ECDHidden);

                        }

                    if (KCDInitialRecordId <= aRecordId &&

	                    KErrNone == aErr)

	                    {

	                    /* This means that the given field is read from the template record and the recordId of the

	                     * record in question (on which the FindL is called) is not a template record as the aRecordId

	                     * is not 0. This means that all of the flags should be removed from the elementId of the

	                     * metaDBVisitor (hidden, modified) and the value should be given back to the client. In this 

	                     * case the user gets the value from the template record, the TMDBElementId of the given field 

	                     * is set so as the value would have been read from the record itself. When StoreL will be called

	                     * on this record and this field is not changed it won't be stored once again in this record but

	                     * remains only in the template record. Of course if the user changes the value of this field it

	                     * will be stored into the given reocrd as the changed flag will be set.

	                     */

	                    metaDBVisitor->ResetElementId(aRecordId);

	                    }

                    //We don't do this branch for mappers because it can just mix up the logic

                    //implemented in the PostMapping functions...

                    else if (KErrNone != aErr &&

                    		!isTheLoadForMapper)

                    	{

                    	/* The reading of the field is still erronous, and this means at this stage that it

                    	 * simply doesn't exist in the given record. What is important in this case is that

                    	 * the value of the given field should be set to NULL, because if it's a container

                    	 * re-use case, meaning that the container is re-used for reading from a record set

                    	 * for example, this is the way we can indicate that the given field is not existing

                    	 * in the record, nor in the template record...

                    	 * This is the 9.5 propagation of the INC123203 

                    	 */

                    	metaDBVisitor->ResetElementId(aRecordId);

                    	metaDBVisitor->ClearValue();

                    	}

                    }

                }

            }

        }

    if (aErr == KErrNotFound)

        {

        aErr = KErrNone;

        }

    }

EXPORT_C TBool MMetaDatabase::FindL(CMDBSession& aSession)

/*

Loads the MMetaDatabase object from the database where match is found for fields primed by the client 

NB this is a depth-first search that assumes that caller will only instantiate links to records that contain 

primed fields that need to be matched.  

This is not attempting to be a generic optimised search solution, but assumes that clients will only search 

down short trees.

Searching time can be significantly reduced by appropriate choice of data container by client.

*/

{

    CMDBSessionImpl* session = aSession.iMDBSessionImpl; 

    RArray<TUint32> candidates;

    RArray<TUint32> matches;

    CleanupClosePushL(candidates);	

    CleanupClosePushL(matches);	

    TBool retval = EFalse;

  	TInt err = KErrNone;

    CMDBElement* thisElement = static_cast<CMDBElement*>(this);

    __FLOG_STATIC1(KLogComponent, KCDInfoLog, _L("MMetaDatabase::FindL() called for Element %08x..."), thisElement->ElementId());

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    CCDMapper* mapper = CCDMapper::MaybeCreateMapperLC(*thisElement,*aSession.iMDBSessionImpl,EFind);    

    if (mapper)

        {   

        //  LOG( ECommsDatLog::Printf(_L8("MMetaDBVisitor %08x:\tFindL() Mapping"), this););

         // Find primed fields that don't need mapping

        DoFindL(session, thisElement, mapper, err, candidates, matches);

        if (err == KErrNone)

            {

            //do some pre-mappings

            mapper->PreMappingsL();

            // Then find any mapped primed fields

            DoFindL(session, mapper, NULL, err, candidates, matches);

            if (err == KErrNone  &&  matches.Count() > 0 )

                {           		

                DoLoadL(session, thisElement, mapper, err, matches[0] & KCDMaskShowRecordId, matches[0] & session->GetReadAttributeMask(), matches);

                if (err == KErrNone || err == KErrNotFound)

			        {

                    // and then Load each mapped entry

                    DoLoadL(session, mapper, NULL, err, matches[0] & KCDMaskShowRecordId, matches[0] & session->GetReadAttributeMask(), matches, ETrue);

                    if (err == KErrNone)

                        {

                        retval = ETrue;

                        if ( matches.Count() > 0 && thisElement->RecordId() == 0 )

                            {

                            thisElement->SetElementId(thisElement->ElementId() | (matches[0] & (KCDMaskShowRecordId | KCDMaskShowAttributes)));

                            }