/**
* 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() )
{
err = KErrNone;
}
CleanupStack::PopAndDestroy(&ids);
}
else
{
err = aSession->StorageL()->FindL(ElementId() & ~aSession->GetReadAttributeMask(), mask, aIds);
}
if ( aIds.Count() == 0)
{
__FLOG_STATIC3(KLogComponent, KCDErrLog, _L("TMDBVisitor<TYPE> FindL() storage server FindL returned err = %d when looking for %08x, masked with %08x"), err, ElementId(), mask);
if (err == KErrNone || err == KErrNotFound)
{
__FLOG_STATIC2(KLogComponent, KCDInfoLog, _L("TMDBVisitor<TYPE> FindL() storage server FindL() did not find <%08x> masked with <%08x>"), ElementId(), mask);
err = KErrNotFound;
}
else
{
__FLOG_STATIC3(KLogComponent, KCDErrLog, _L("TMDBVisitor<TYPE> FindL() storage server FindL returned err = %d when looking for <%08x>, masked with <%08x>"), err, ElementId(), mask);
}
}
#ifdef __DEBUG
else if ( aIds->Count() > 1)
{
__FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<TYPE> FindL() storage server FindL/FindEqL %d fields found for id %08x. Should be 1 or 0."), aIds.Count(), id & mask);
}
#endif
return err;
}
template <>
inline TInt TMDBVisitor<HBufC16*>::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 || ! iTarget->iValue )
{
User::Leave(KErrNotReady);
}
// 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();
TInt err(KErrNotFound);
if (Changed())
{
const TDesC16& val = *iTarget->iValue;
// An absent text field is treated as being synonymous with one that is present but blank, ie
// searching for an empty descriptor matches both actual blanks and fields that aren't found. Because
// CenRep doesn't support such a thing we're forced to get handle this case by brute force: get the set
// of all record ids, fetch the desired field for each, and remove those records where the field is present
// and non blank.
if(val.Length() == 0)
{
// Get the set of all recordIds
TUint32 maskId = KCDMaskHideAttrAndRes & ~KCDColumnTypeInfo;
TUint32 tableId = ElementId() | KCDMaskShowColumnTypeAndRecordId;
err = (aSession->StorageL())->FindL(tableId, maskId, aIds);
// remove node (side effect from query)
for (TInt idx = aIds.Count() - 1; idx >= 0; -- idx)
{
if( (aIds[idx] & ~KCDMaskShowAttrAndRes) == (tableId & ~KCDMaskShowAttrAndRes) )
{
aIds.Remove(idx);
}
}
if ( err != KErrNone && err != KErrNotFound )
{
__FLOG_STATIC3(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC16*> FindL() storage server FindL returned err = %d when looking for <%08x>, masked with <%08x>"), err, tableId, mask);
}
else
{
// Fetch the desired field for each record
RArray<TUint32> fieldIds;
CleanupClosePushL(fieldIds);
TUint32 fieldId = (ElementId() & ~KCDMaskShowRecordId);
maskId = KCDMaskShowType | aSession->GetReadAttributeMask();
TInt errFieldSearch = aSession->StorageL()->FindL(fieldId, maskId, fieldIds);
if(errFieldSearch == KErrNone)
{
for(TInt fieldIdx = fieldIds.Count() - 1; fieldIdx >= 0; --fieldIdx)
{
for (TInt idx = aIds.Count() - 1; idx >= 0; -- idx)
{
// Remove those records where the field is present and non blank
if( (fieldIds[fieldIdx] & KCDMaskShowRecordId) == (aIds[idx] & KCDMaskShowRecordId ))
{
aIds.Remove(idx);
}
}
}
}
CleanupStack::PopAndDestroy(&fieldIds);
}
}
else
{
if((ElementId() & KCDMaskHideRes) == KCDMaskGenericTableName)
{
mask = KCDMaskGenericTableName;
}
err = aSession->StorageL()->FindEqL(ElementId() & ~aSession->GetReadAttributeMask(), mask, val, aIds);
RArray<TUint32> ids;
CleanupClosePushL(ids);
mask = (mask & ~ECDHidden) | KCDMaskShowRecordId;
// Now look in template record
err = aSession->StorageL()->FindEqL(ElementId() & ~KCDMaskShowRecordId, mask, val, ids);
if ( err == KErrNone )
{
FindRecordsUsingTemplateL(aSession, ids, aIds);
}
if ( aIds.Count() )
{
err = KErrNone;
}
CleanupStack::PopAndDestroy(&ids);
}
}
else
{
err = aSession->StorageL()->FindL(ElementId() & ~aSession->GetReadAttributeMask(), mask, aIds);
}
if ( aIds.Count() == 0)
{
__FLOG_STATIC3(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC16*> FindL() storage server FindL returned err = %d when looking for %08x, masked with %08x"), err, ElementId(), mask);
if (err == KErrNone || err == KErrNotFound)
{
__FLOG_STATIC2(KLogComponent, KCDInfoLog, _L("TMDBVisitor<HBufC16*> FindL() storage server FindL() did not find <%08x> masked with %08x"), ElementId(), mask);
err = KErrNotFound;
}
else
{
__FLOG_STATIC3(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC16*> FindL() storage server FindL() returned err = %d when looking for <%08x>, masked with <%08x>"), err, ElementId(), mask);
}
}
#ifdef __DEBUG
else if ( aIds->Count() > 1)
{
__FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC16*> FindL() storage server FindL/FindEqL %d fields found for id. Should be 1 or 0."), aIds.Count(), ElementId() & mask);
}
#endif
return err;
}
template <>
inline TInt TMDBVisitor<HBufC8*>::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 || ! iTarget->iValue )
{
User::Leave(KErrNotReady);
}
// 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();
TInt err(KErrNotFound);
if (Changed())
{
const TDesC8& val = *iTarget->iValue;
// An absent text field is treated as being synonymous with one that is present but blank, ie
// searching for an empty descriptor matches both actual blanks and fields that aren't found. Because
// CenRep doesn't support such a thing we're forced to get handle this case by brute force: get the set
// of all record ids, fetch the desired field for each, and remove those records where the field is present
// and non blank.
// @TODO - find a cleaner way to achieve this
if(val.Length() == 0)
{
TUint32 recId = (ElementId() & ~KCDMaskShowFieldType) | KCDInitialColumnId;
err = aSession->StorageL()->FindL(recId & ~aSession->GetReadAttributeMask(), mask, aIds);
if(err == KErrNone)
{
TBuf8<1> dummyVal; // doesn't matter if it overflows; mere presence of non-blank is all we seek
for(TInt idx = aIds.Count() - 1; idx >= 0; --idx)
{
TUint32 fldId = (aIds[idx] & ~KCDMaskShowFieldType) | (ElementId() & KCDMaskShowFieldType);
TInt lookupErr = aSession->StorageL()->Get(fldId, dummyVal);
if(lookupErr == KErrOverflow || (lookupErr == KErrNone && dummyVal.Length() != 0))
{
// comparison field does exist in this specific record but didn't match "" - remove
aIds.Remove(idx);
}
}
}
}
else
{
err = aSession->StorageL()->FindEqL(ElementId() & ~aSession->GetReadAttributeMask(), mask, val, aIds);
RArray<TUint32> ids;
CleanupClosePushL(ids);
mask = (mask & ~ECDHidden) | KCDMaskShowRecordId;
// Now look in template record
err = aSession->StorageL()->FindEqL(ElementId() & ~KCDMaskShowRecordId, mask, val, ids);
if ( err == KErrNone )
{
FindRecordsUsingTemplateL(aSession, ids, aIds);
}
if ( aIds.Count() )
{
err = KErrNone;
}
CleanupStack::PopAndDestroy(&ids);
}
}
else
{
err = aSession->StorageL()->FindL(ElementId() & ~aSession->GetReadAttributeMask(), mask, aIds);
}
if ( aIds.Count() == 0)
{
__FLOG_STATIC3(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC8*> FindL() storage server FindL returned err = %d when looking for %08x, masked with %08x"), err, ElementId(), mask);
if (err == KErrNone || err == KErrNotFound)
{
__FLOG_STATIC2(KLogComponent, KCDInfoLog, _L("TMDBVisitor<HBufC8*> FindL() storage server FindL did not find <%08x> masked with <%08x>"), ElementId(), mask);
err = KErrNotFound;
}
else
{
__FLOG_STATIC3(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC8*> FindL() storage server FindL returned err = %d when looking for <%08x>, masked with <%08x>"), err, ElementId(), mask);
}
}
#ifdef __DEBUG
else if ( aIds->Count() > 1)
{
__FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC8*> FindL() storage server FindL/FindEqL %d fields found when looking for <%08x>. Should be 1 or 0."), aIds.Count(), ElementId() & mask);
}
#endif
return err;
}
template<class TYPE>
inline TInt TMDBVisitor<TYPE>::StoreL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags)
/*
Store the field in the repository
@internalComponent
*/
{
if (! iTarget || ! iElementId )
{
User::Leave(KErrNotReady);
}
*iElementId = (*iElementId & ~KCDMaskShowRecordId) | (aRecordId & KCDMaskShowRecordId) | aAttributeFlags;
return aSession->StorageL()->Create( ElementId() & KCDMaskHideRes, iTarget->iValue);
}
template<>
inline TInt TMDBVisitor<HBufC16*>::StoreL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags)
/*
Store the field in the repository
@internalComponent
*/
{
if (! iTarget || ! iElementId )
{
User::Leave(KErrNotReady);
}
*iElementId = (*iElementId & ~KCDMaskShowRecordId) | (aRecordId & KCDMaskShowRecordId) | aAttributeFlags;
return aSession->StorageL()->Create( ElementId() & KCDMaskHideRes, *(iTarget->iValue));
}
template<>
inline TInt TMDBVisitor<HBufC8*>::StoreL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags)
/*
Store the field in the repository
@internalComponent
*/
{
if (! iTarget || ! iTarget->iValue )
{
User::Leave(KErrNotReady);
}
*iElementId = (*iElementId & ~KCDMaskShowRecordId) | (aRecordId & KCDMaskShowRecordId) | aAttributeFlags;
return aSession->StorageL()->Create( ElementId() & KCDMaskHideRes, *(iTarget->iValue));
}
template<class TYPE>
inline TInt TMDBVisitor<TYPE>::ModifyL(CMDBSessionImpl* aSession, TMDBAttributeFlags aAttributeFlags)
/*
Modify the value of a field if the field exists
Never need to modify attributes as this is always done via the node.
@internalComponent
*/
{
TInt err(KErrNotFound);
if (! iTarget || !iElementId )
{
User::Leave(KErrNotReady);
}
*iElementId |= aAttributeFlags;
TUint32 mask = (KCDMaskShowType | KCDMaskShowRecordId);
RArray<TUint32> ids;
CleanupClosePushL(ids);
err = aSession->StorageL()->FindL(ElementId(), mask, ids);
if (ids.Count() > 0)
{
#ifdef __DEBUG
if (ids.Count() > 1)
{
__FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<TYPE> ModifyL() storage server FindL/FindEqL %d fields found when looking for id %08x. Should be 1 or 0."), aIds.Count(), ElementId() & mask);
}
#endif
err = aSession->StorageL()->Set(ElementId() & KCDMaskHideRes, iTarget->iValue);
}
else
{
err = aSession->StorageL()->Create(ElementId() & KCDMaskHideRes, iTarget->iValue);
}
CleanupStack::PopAndDestroy(&ids);
return err;
}
template<>
inline TInt TMDBVisitor<HBufC16*>::ModifyL(CMDBSessionImpl* aSession, TMDBAttributeFlags aAttributeFlags)
/*
ElementId must be fully resolved before this call
@internalComponent
*/
{
if (! iTarget || !iElementId )
{
User::Leave(KErrNotReady);
}
*iElementId |= aAttributeFlags;
TUint32 mask = KCDMaskShowType | KCDMaskShowRecordId;
RArray<TUint32> ids;
CleanupClosePushL(ids);
TInt err = aSession->StorageL()->FindL(ElementId(), mask, ids);
if (ids.Count() > 0)
{
#ifdef DEBUG
if (ids.Count() > 1)
{
__FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<TYPE> ModifyL() storage server FindL/FindEqL %d fields found when looking for id %08x. Should be 1 or 0."), aIds.Count(), ElementId() & mask);
}
#endif
if(! iTarget->iValue)
{
return KErrNone;
}
err = aSession->StorageL()->Set(ElementId() & KCDMaskHideRes, *(iTarget->iValue));
}
else
{
if(! iTarget->iValue)
{
return KErrNone;
}
err = aSession->StorageL()->Create(ElementId() & KCDMaskHideRes, *(iTarget->iValue));
}
CleanupStack::PopAndDestroy(&ids);
return err;
}
template<>
inline TInt TMDBVisitor<HBufC8*>::ModifyL(CMDBSessionImpl* aSession, TMDBAttributeFlags aAttributeFlags)
/*
ElementId must be fully resolved before this call
@internalComponent
*/
{
if (! iTarget || !iElementId )
{
User::Leave(KErrNotReady);
}
*iElementId |= aAttributeFlags;
TUint32 mask = KCDMaskShowType | KCDMaskShowRecordId;
RArray<TUint32> ids;
CleanupClosePushL(ids);
TInt err = aSession->StorageL()->FindL(ElementId(), mask, ids);
if (ids.Count() > 0)
{
#ifdef __DEBUG
if (ids.Count() > 1)
{
__FLOG_STATIC2(KLogComponent, KCDErrLog, _L("TMDBVisitor<HBufC8*> ModifyL() storage server FindL/FindEqL %d fields found when looking for %08x. Should be 1 or 0."), ids.Count(), ElementId() & mask);
}
#endif
if(! iTarget->iValue)
{
return KErrNone;
}
err = aSession->StorageL()->Set(ElementId() & KCDMaskHideRes, *(iTarget->iValue));
}
else
{
if(! iTarget->iValue)
{
return KErrNone;
}
err = aSession->StorageL()->Create(ElementId() & KCDMaskHideRes, *(iTarget->iValue));
}
CleanupStack::PopAndDestroy(&ids);
return err;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Record Set Visitor
//
NONSHARABLE_CLASS(TMDBRecordSetVisitor) : public TMDBVisitorBase
/*
A visitor for CMDBRecordSet.data
@internalComponent
*/
{
public:
static TMDBRecordSetVisitor* NewL(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);
// SET
TInt StoreL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags);
TInt ModifyL(CMDBSessionImpl* aSession, TMDBAttributeFlags aAttributeFlags);
TInt Changed() const;
void Sync(){} // do nothing - leave changed flag set
//void SetOwner(CMDBElement* aOwner);
public:
RPointerArray<CMDBRecordBase>* iTarget;
protected:
TMDBRecordSetVisitor(RPointerArray<CMDBRecordBase>* aData);
private:
void DoFindL(CMDBSessionImpl& aSession, CMDBElement& aElement, TInt& aErr, RArray<TUint32>& aCandidates, RArray<TUint32>& aMatches);
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Record Link Visitor
//
NONSHARABLE_CLASS(TMDBRecordLinkVisitor) : public TMDBVisitor<TInt>
/*
A visitor for linked record data
@internalComponent
*/
{
public:
static TMDBRecordLinkVisitor* NewL(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);
private:
void SetLinkValueL(CMDBSession& aSession);
void CheckLinkedRecordL(TMDBElementId aLinkedElementId);
void CreateLinkedRecordL(CMDBSession& aSession, TMDBElementId aLinkedElementId);
void CheckLinkValueL(TMDBElementId aLinkedElementId);
void MaintainBCForLegacyLinks();
public:
CMDBElement** iLinkedRecord;
protected:
TMDBRecordLinkVisitor(CMDBElement** aData);
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// User defined Record Visitor
//
NONSHARABLE_CLASS(TMDBGenericRecordVisitor) : public TMDBVisitorBase
/*
A visitor for data inside a user-defined record
@internalComponent
*/
{
public:
static TMDBGenericRecordVisitor* NewL(const TAny* aMem, const TAny* aData);
// GET
void LoadTableInfoL(CMDBSessionImpl& aSession, TMDBAttributeFlags aAttributeFlags, CMDBGenericRecord& aRealOwner);
TInt LoadL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags);
TInt LoadL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags, RArray<TUint32>& aIds);
void FindTableL(CMDBSessionImpl& aSession, CMDBGenericRecord& aRealOwner, RArray<TUint32>& aMatchingIds);
TInt FindL(CMDBSessionImpl* aSession, RArray<TUint32>& aIds);
TInt RefreshL(CMDBSessionImpl* aSession);
// SET
void StoreTableInfoL(CMDBSessionImpl& aSession, CMDBGenericRecord& aRealOwner);
TInt StoreL(CMDBSessionImpl* aSession, TMDBElementId aRecordId, TMDBAttributeFlags aAttributeFlags);
TInt ModifyL(CMDBSessionImpl* aSession, TMDBAttributeFlags aAttributeFlags);
TInt Changed() const;
void Sync(){} // do nothing - leave changed flag set
//void SetOwner(CMDBElement* aOwner);
public:
RPointerArray<CMDBElement>* iTarget;
protected:
TMDBGenericRecordVisitor(RPointerArray<CMDBElement>* aData);
TMDBVisitorBase* CreateVisitorL(TAny* mem, CMDBElement* element, SGenericRecordTypeInfo* aRecordInfo);
private:
CMDBGenericRecord* SetReadyL();
};
} // End namespace CommsDat
#endif //METADATABASEVISITOR_H