/**

* 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:

*

*/

/**

 @file MetaDatabaseVisitor.h

 @internalComponent

*/

#if (!defined METADATABASEVISITOR_H)

#define       METADATABASEVISITOR_H

namespace CommsDat

/*

Namespace encapsulates all types that are able to perform MMetaDatabase actions on specific record data types

*/

    {

using namespace CommsDatInternal;

using namespace Meta;

NONSHARABLE_CLASS(TMDBVisitorBase) : public Meta::MMetaType

/**

A general database visitor 

@internalComponent

*/

    {  

public:

    virtual ~TMDBVisitorBase();

    ////////// From Meta::MMetaType /////////////////////////////////////////

       TInt Load(TPtrC8& aBuffer){ aBuffer == aBuffer; return 0; }

       TInt Store(TDes8& aBuffer) const{aBuffer == aBuffer; return 0; }

       void Copy(const TAny* aData)  {aData = aData;}

       TInt Length() const {return 0;}

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

    // GET

    virtual TInt LoadL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags) = 0; 

    virtual TInt LoadL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags, RArray<TUint32>& aIds) = 0;

    virtual TInt FindL(CMDBSessionImpl* aSession, RArray<TUint32>& aIds) = 0;

    virtual TInt RefreshL(CMDBSessionImpl* aSession) = 0;

	virtual TInt GetL(CMDBSessionImpl* aSession);

    // SET

    virtual TInt StoreL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags) = 0;

    virtual TInt ModifyL(CMDBSessionImpl* aSession, TMDBAttributeFlags aAttributeFlags) = 0;

    virtual void SetOwner(CMDBElement* aOwner);

    virtual TInt Changed() const = 0;  

    virtual void Sync();

    virtual void ClearValue(){}

public:

    // These do not need to be specialised in inheriting templates

    void Change();

    void FieldLoaded();

    TBool IsFieldLoaded();

    void SetFieldNull();

	TUint32 TypeId();

    TUint32 ElementId();

    void SetElementId(TMDBElementId* aId);

    void SetElementId(TMDBElementId aId);

    void SetMaxLength(TInt aLength);

    /* Removes all of the flags from the elementId of the DBVisitor - use only if the given record

     * which needs to be loaded is NOT a template record!! Doesn't have to be virtual.

     */

    void ResetElementId(TInt aRecId);

protected:

    TMDBVisitorBase(TMDBElementId *aElementId);

    TMDBVisitorBase();

    void FindRecordsUsingTemplateL(CMDBSessionImpl* aSession, RArray<TUint32>& aRecordIds, RArray<TUint32>& aCandidateIds);

    TInt            iMaxLength;  

    CMDBElement*    iOwner; 

    TMDBElementId*  iElementId;

    };

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

// TMDBVisitor

// 

/**

Generic visitor for any simple MetaDatabase element.

Class is specialised to act on fields of type TMDBMetaField<T>

where T is 

    TInt    - (for any number - reals not used in comms database)

    HBufC   - for any string

    HBufC8  - for binary data

*/

/*Simple encapsulation of a metadatabase element for use by visitors

@internalComponent

*/

template<class TYPE> 

struct SMDBMetaElement 

    {

    TMDBElementId   iElementId;

    TYPE            iValue;

    };

/*

Implementation of MMetaDBVisitor for a general type 

@internalComponent

*/

template <class TYPE> 

class TMDBVisitor : public TMDBVisitorBase

/**

Implementation of MMetaDBVisitor for a general element type 

@internalComponent

*/

    {    

public:

    inline static TMDBVisitor<TYPE>* NewL(const TAny* aMem, const TAny* aData);

    inline static TMDBVisitor<TYPE>* CreateL(const TAny* aMem, const TAny* aData);

    // GET

    TInt LoadL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags); 

    TInt LoadL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags, RArray<TUint32>& aIds);

    TInt FindL(CMDBSessionImpl* aSession, RArray<TUint32>& aIds);

    TInt RefreshL(CMDBSessionImpl* aSession);

	TInt GetL(CMDBSessionImpl* aSession);

    // SET

    TInt StoreL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags);

    TInt ModifyL(CMDBSessionImpl* aSession, TMDBAttributeFlags aAttributeFlags);  

	TInt Changed() const;

    //void SetOwner(CMDBElement* aOwner);

    void ClearValue();

public:

    SMDBMetaElement<TYPE>* iTarget;

protected:

    TMDBVisitor(SMDBMetaElement<TYPE>* aData);

    };

template <class TYPE> 

inline TMDBVisitor<TYPE>::TMDBVisitor(SMDBMetaElement<TYPE>* aData)

: TMDBVisitorBase(&(aData->iElementId)), iTarget(aData)

/**

 * Constructor

 */

    {

    }

template<class TYPE> 

inline TMDBVisitor<TYPE>* TMDBVisitor<TYPE>::NewL(const TAny* aMem, const TAny* aData)

/**

 * Instantiates a Visitor of a particular type.

 * Used for attribute registration (in the data v-table).

 */

    {

    return static_cast<TMDBVisitor<TYPE>*>( ::new ((TUint8*)aMem) TMDBVisitor( (SMDBMetaElement<TYPE>*)(aData) ) );

    }

template<class TYPE> 

inline TMDBVisitor<TYPE>* TMDBVisitor<TYPE>::CreateL(const TAny* aMem, const TAny* aData)

/**

 * Instantiates a Visitor of a particular type.

 * Used for attribute registration (in the data v-table).

 */

    {

    return static_cast<TMDBVisitor<TYPE>*>( ::new ((TUint8*)aMem) TMDBVisitor( (SMDBMetaElement<TYPE>*)(((CMDBElement*)aData)->Data()) ) );

    }

template <class TYPE> 

inline TInt TMDBVisitor<TYPE>::Changed() const

/*

Has the value been changed by the caller?

@internalComponent

*/  { 

    if (iElementId)

        {

        return ( *iElementId & KCDChangedFlag );

    	}

    return 0;

    } 

template<class TYPE>

inline void TMDBVisitor<TYPE>::ClearValue() 

    {

    if (iTarget)

        {

        iTarget->iValue = 0;

        SetFieldNull();

        }

    }

template<>

inline void TMDBVisitor<HBufC16*>::ClearValue() 

    {

    if (iTarget)

        {

        delete iTarget->iValue;

        iTarget->iValue = 0;

        SetFieldNull();

        }

    }

template<>

inline void TMDBVisitor<HBufC8*>::ClearValue() 

    {

    if (iTarget)

        { 

        delete iTarget->iValue;

        iTarget->iValue = 0;

        SetFieldNull();

        }

    }

template<class TYPE> 

inline TInt TMDBVisitor<TYPE>::RefreshL(CMDBSessionImpl* aSession) 

	{

	return LoadL(aSession,*iElementId,*iElementId);

	}

template<class TYPE> 

inline TInt TMDBVisitor<TYPE>::GetL(CMDBSessionImpl* aSession) 

/*

Assumes fully resolved element Id but still needs mask for reserved bits

@internalComponent

*/

    {

    if (! iTarget )

        {

        User::Leave(KErrNotReady);

        }

    TUint32 id = ElementId() & ~KCDMaskShowRes;

    TInt err = aSession->StorageL()->Get(id, iTarget->iValue);

    if(err == KErrNone)

		{

		FieldLoaded(); // value has been retrieved

		}

    else 

        {

        Sync(); // indicates the field is still null.  

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

            {

            __FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<TYPE> GetL() storage server Get returned err = %d for id %08x"), err, id);

            User::Leave(err);

            }

        }

	return err;

    }

template<> 

inline TInt TMDBVisitor<HBufC16*>::GetL(CMDBSessionImpl* aSession) 

/*

Specialisation for HBufC16 

Assumes fully resolved element Id but still needs mask for reserved bits

@internalComponent

*/

	{

	if (! iTarget )

        {

        User::Leave(KErrNotReady);

        }

    if( ! iTarget->iValue  || 

		iTarget->iValue->Length() < iMaxLength)

		{

		delete iTarget->iValue;

        iTarget->iValue = NULL;

		iTarget->iValue = HBufC16::NewMaxL(iMaxLength);

		}

	TPtr16 ptr = iTarget->iValue->Des();

	TUint32 id = ElementId() & KCDMaskHideRes;

    TInt err = aSession->StorageL()->Get(id, ptr);   

    if(err == KErrNone)

		{

		FieldLoaded(); // value has been loaded

		HBufC16* temp = iTarget->iValue;

		iTarget->iValue = HBufC16::NewMaxL(ptr.Length());

		TPtr16 ptrNew = iTarget->iValue->Des();;

		ptrNew = ptr;

		delete temp;

		}

    else 

        {

        delete iTarget->iValue;

        iTarget->iValue = NULL;

        Sync(); // indicates the field is null.  

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

            {

            __FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC16*> GetL() storage server Get returned err = %d for id %08x"), err, id);

            User::Leave(err);

            }

        }

    return err;

	}

template<> 

inline TInt TMDBVisitor<HBufC8*>::GetL(CMDBSessionImpl* aSession) 

/*

Specialisation for HBufC8*

Assumes fully resolved element Id but still needs mask for reserved bits

@internalTechnology

*/

    {

    if (! iTarget )

        {

        User::Leave(KErrNotReady);

        }

    if (! iTarget->iValue || 

		iTarget->iValue->Length() < iMaxLength)

		{

		delete iTarget->iValue;

		iTarget->iValue = NULL;

		iTarget->iValue = HBufC8::NewMaxL(iMaxLength);

		}

	TPtr8 ptr = iTarget->iValue->Des();

    TUint32 id = ElementId() & KCDMaskHideRes;

	TInt err = aSession->StorageL()->Get(id, ptr);    

    if(err == KErrNone)

		{

		FieldLoaded();// Value was retrieved

        /*

		HBufC8* temp = iTarget->iValue;

		iTarget->iValue = HBufC8::NewMaxL(ptr.Length());

		TPtr8 ptrNew = iTarget->iValue->Des();;

		ptrNew = ptr;

		delete temp;

        */

		}

    else 

        {

        delete iTarget->iValue;

        iTarget->iValue = NULL;

        Sync(); // indicates the field is null.  

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

            {

            __FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC8*> GetL() storage server Get returned err = %d for id %08x"), err, id);

            User::Leave(err);

            }

        }

	return err;

    }

template<class TYPE> 

inline TInt TMDBVisitor<TYPE>::LoadL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags /*aAttributeFlags*/) 

/*

Assumes type and record id set by caller

@internalComponent

*/

    {

    if (! iTarget)

        {

        User::Leave(KErrNotReady);

        }

    // set the element id to the full id set by the caller

    iTarget->iElementId = (iTarget->iElementId & (KCDMaskShowType | KCDMaskShowRes)) | (aRecordId & KCDMaskShowRecordId);  

    RArray<TUint32> ids;

	CleanupClosePushL(ids);

	TUint32 mask = KCDMaskShowType | KCDMaskShowRecordId | aSession->GetReadAttributeMask();

	TUint32 id = ElementId() & KCDMaskHideAttrAndRes;

    TInt err = (aSession->StorageL())->FindL(id, mask, ids);  

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

        {

        __FLOG_STATIC3(KLogComponent, KCDErrLog, _L("TMDBVisitor<TYPE> LoadL() storage server FindL returned err = %d when looking for %08x, masked with %08x"), err, id, mask);

        }

#ifdef __DEBUG    

    else if ( ids.Count() > 1 )

        {

        __FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<TYPE> LoadL() storage server FindL/FindEqL %d fields found for %08x.  Should be 1 or 0."), aIds.Count(), id & mask);

        }

#endif

    // Load the field data

    if (err == KErrNone)

        {

	    // Set the full id 

		iTarget->iElementId = ids[0];

		err = GetL(aSession); 		

        }

	CleanupStack::PopAndDestroy(&ids);

    if ( err == KErrNotFound )

        {

        // it's ok not to find a field.  

        // Don't report that error back.

       // VCT - experimenting without this err = KErrNone;

        }

	return err;

    }

template<class TYPE> 

inline TInt TMDBVisitor<TYPE>::LoadL(CMDBSessionImpl* aSession, TMDBElementId /*aRecordId*/, TMDBAttributeFlags /*aAttributeFlags*/,RArray<TUint32>& aIds ) 

/*

Assumes type and record id set by caller

@internalComponent

*/

    {

    if (aIds.Count() == 0)

        {

        User::Leave(KErrNotFound);

        }

    return LoadL(aSession, aIds[0] & KCDMaskShowRecordId, aIds[0] & KCDMaskShowAttributes);

    }

template <class TYPE> 

inline TInt TMDBVisitor<TYPE>::FindL(CMDBSessionImpl* aSession, RArray<TUint32>& aIds) 

/*

Only find dont actually load

Assumes fully resolved element Id but still needs mask for reserved bits

@internalComponent

*/

    {

    if (! iTarget )

        {

        User::Leave(KErrNotReady);

        }

    TInt err(KErrNotFound);

    // want to find this field in any record of this type that has appropriate attributes

    // so mask out recordid, reserved bits and any attributes that need not be observed.

    // TUint32 mask = KCDMaskShowType | (~aAttributeFlags & KCDMaskShowAttributes);

    TUint32 mask = KCDMaskShowType | aSession->GetReadAttributeMask();

    if (Changed())

        {

        err = aSession->StorageL()->FindEqL(ElementId() & ~aSession->GetReadAttributeMask(), mask, iTarget->iValue, aIds);

        RArray<TUint32> ids;

        CleanupClosePushL(ids);

        mask = (mask & ~ECDHidden) | KCDMaskShowRecordId;

        // Now look in template record to find other records

        err = aSession->StorageL()->FindEqL(ElementId() & ~KCDMaskShowRecordId, mask, iTarget->iValue, ids);

        if ( err == KErrNone )

            {

            FindRecordsUsingTemplateL(aSession, ids, aIds);

            }

        if ( aIds.Count() )

            {