diff -r 000000000000 -r c53acadfccc6 metadataengine/client/src/mdeobjectcondition.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/metadataengine/client/src/mdeobjectcondition.cpp Mon Jan 18 20:34:07 2010 +0200 @@ -0,0 +1,440 @@ +/* +* Copyright (c) 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: ?Description +* +*/ + +#include "mdeobjectcondition.h" +#include "mdcserializationbuffer.h" +#include "mdeobjectdef.h" +#include "mdepanic.h" +#include "mdscommoninternal.h" +#include "mdcquery.h" + + +CMdEObjectCondition* CMdEObjectCondition::NewL( TObjectConditionCompareMethod aCompareMethod, + TItemId aObjectId, const CMdEObjectDef* aObjectDef, + TInt64 aObjectGuidHigh, TInt64 aObjectGuidLow ) + { + CMdEObjectCondition* self = CMdEObjectCondition::NewLC( aCompareMethod, + aObjectId, aObjectDef, aObjectGuidHigh, aObjectGuidLow ); + CleanupStack::Pop( self ); + return self; + } + +CMdEObjectCondition* CMdEObjectCondition::NewLC( TObjectConditionCompareMethod aCompareMethod, + TItemId aObjectId, const CMdEObjectDef* aObjectDef, + TInt64 aObjectGuidHigh, TInt64 aObjectGuidLow ) + { + CMdEObjectCondition* self = new (ELeave) CMdEObjectCondition( aCompareMethod, + aObjectId, aObjectDef, aObjectGuidHigh, aObjectGuidLow ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +CMdEObjectCondition* CMdEObjectCondition::NewL( TObjectConditionCompareMethod aCompareMethod, + const RArray* aObjectIds, const TDesC* aString, const TMdEUintRange* aRange ) + { + CMdEObjectCondition* self = CMdEObjectCondition::NewLC( aCompareMethod, aObjectIds, aString, aRange ); + CleanupStack::Pop( self ); + return self; + } + +CMdEObjectCondition* CMdEObjectCondition::NewLC( TObjectConditionCompareMethod aCompareMethod, + const RArray* aObjectIds, const TDesC* aString, const TMdEUintRange* aRange ) + { + CMdEObjectCondition* self = new (ELeave) CMdEObjectCondition( aCompareMethod ); + CleanupStack::PushL( self ); + self->ConstructL( aObjectIds, aString, aRange ); + return self; + } + + +CMdEObjectCondition::CMdEObjectCondition( TObjectConditionCompareMethod aCompareMethod, + TItemId aObjectId, const CMdEObjectDef* aObjectDef, + TInt64 aObjectGuidHigh, TInt64 aObjectGuidLow ) + : CMdECondition(EConditionTypeObject), iObjectDef( aObjectDef ), + iObjectId( aObjectId ), iObjectIds( NULL ), + iString( NULL ), iCompareMethod( aCompareMethod ), iFlags( 0 ), + iConfidentialityLevel(EObjectConditionLevelNormal), + iGuidHigh( aObjectGuidHigh ), iGuidLow( aObjectGuidLow ), + iRange( NULL ) + { + #ifdef _DEBUG + if ( iObjectDef ) + { + __ASSERT_DEBUG(aCompareMethod == EObjectConditionCompareObjectDef, TMdEPanic::Panic(TMdEPanic::EInternal)); + } + else if ( iObjectId != KNoId ) + { + __ASSERT_DEBUG(aCompareMethod == EObjectConditionCompareId, TMdEPanic::Panic(TMdEPanic::EInternal)); + } + else if ( iGuidHigh != 0 || iGuidLow != 0 ) + { + __ASSERT_DEBUG(aCompareMethod == EObjectConditionCompareGuid, TMdEPanic::Panic(TMdEPanic::EInternal)); + } + else + { + __ASSERT_DEBUG(aCompareMethod == EObjectConditionCompareNone, TMdEPanic::Panic(TMdEPanic::EInternal)); + } + + #endif + } + +CMdEObjectCondition::CMdEObjectCondition( TObjectConditionCompareMethod aCompareMethod ) + : CMdECondition(EConditionTypeObject), iObjectDef( NULL ), + iObjectId( KNoId ), iObjectIds( NULL ), + iString( NULL ), iCompareMethod( aCompareMethod ), iFlags( 0 ), + iConfidentialityLevel(EObjectConditionLevelNormal), iGuidHigh( 0 ), iGuidLow( 0 ) + { + __ASSERT_DEBUG(iCompareMethod > EObjectConditionCompareFirst && iCompareMethod < EObjectConditionCompareLast, TMdEPanic::Panic(TMdEPanic::EInternal)); + } + +void CMdEObjectCondition::ConstructL() + { + // Base class construction. + ConditionConstruct(); + + // Non-confidential objects are queried by default + iConfidentialityLevel = EObjectConditionLevelNormal; + } + +void CMdEObjectCondition::ConstructL( const RArray* aObjectIds, + const TDesC* aString, const TMdEUintRange* aRange ) + { + if ( aString ) + { + iString = HBufC::NewL(aString->Length()); + iString->Des().CopyLC( *aString ); + } + else if ( aObjectIds ) + { + iObjectIds = new (ELeave) RArray; + + const TInt objectIdCount = aObjectIds->Count(); + iObjectIds->ReserveL( objectIdCount ); + + for( TInt i = 0; i < objectIdCount; i++ ) + { + iObjectIds->Append( (*aObjectIds)[i] ); + } + } + else if ( aRange ) + { + iRange = new(ELeave) TMdEUintRange(*aRange); + } + else + { + User::Leave( KErrArgument ); + } + } + +CMdEObjectCondition::~CMdEObjectCondition() + { + delete iString; + + if( iObjectIds ) + { + iObjectIds->Close(); + + delete iObjectIds; + } + + delete iRange; + } + +EXPORT_C const CMdEObjectDef* CMdEObjectCondition::ObjectDef() const + { + return iObjectDef; + } + +EXPORT_C TItemId CMdEObjectCondition::ObjectId() const + { + return iObjectId; + } + +EXPORT_C const RArray* CMdEObjectCondition::ObjectIds() const + { + return iObjectIds; + } + +EXPORT_C const TDesC* CMdEObjectCondition::String() const + { + return iString; + } + + +EXPORT_C TObjectConditionCompareMethod CMdEObjectCondition::CompareMethod() const + { + return iCompareMethod; + } + + +EXPORT_C TObjectConditionConfidentialityLevel CMdEObjectCondition::ConfidentialityLevel() const + { + return iConfidentialityLevel; + } + +EXPORT_C void CMdEObjectCondition::SetConfidentialityLevel( TObjectConditionConfidentialityLevel aLevel ) + { + iConfidentialityLevel = aLevel; + } + +EXPORT_C TBool CMdEObjectCondition::NotPresent() const + { + return iFlags & EMdEObjectFlagNotPresent ? ETrue : EFalse; + } + +EXPORT_C void CMdEObjectCondition::SetNotPresent(TBool aNotPresent) + { + if( aNotPresent ) + { + iFlags |= EMdEObjectFlagNotPresent; + } + else + { + iFlags &= ~EMdEObjectFlagNotPresent; + } + } + +EXPORT_C TBool CMdEObjectCondition::NotPlaceholder() const + { + return iFlags & EMdEObjectFlagPlaceholder ? ETrue : EFalse; + } + +EXPORT_C void CMdEObjectCondition::SetNotPlaceholder(TBool aNotPlaceholder) + { + if( aNotPlaceholder ) + { + iFlags |= EMdEObjectFlagPlaceholder; + } + else + { + iFlags &= ~EMdEObjectFlagPlaceholder; + } + } + +EXPORT_C TBool CMdEObjectCondition::PlaceholderOnly() const + { + return iPlaceholdersOnly; + } + +EXPORT_C void CMdEObjectCondition::SetPlaceholderOnly(TBool aPlaceholderOnly ) + { + iPlaceholdersOnly = aPlaceholderOnly; + } + +TUint32 CMdEObjectCondition::InternalQueryOptimizationFlags(TUint32& aFlags) + { + TUint32 optimizationFlags = EContainsObjectCondition; + + if( iFlags & EMdEObjectFlagNotPresent ) + { + optimizationFlags |= EContainsNotPresentCondition; + } + + switch( iCompareMethod ) + { + case EObjectConditionCompareFreeText: + case EObjectConditionCompareFreeTextContains: + case EObjectConditionCompareFreeTextBeginsWith: + case EObjectConditionCompareFreeTextEndsWith: + optimizationFlags |= EContainsFreetextCondition; + break; + default: + break; + } + + if( iPlaceholdersOnly ) + { + optimizationFlags |= EContainsPlaceholdersOnly; + } + + aFlags |= optimizationFlags; + return optimizationFlags; + } + +TUint32 CMdEObjectCondition::RequiredBufferSize() const + { + TUint32 bufferSize = sizeof( TMdCObjectCondition ); + + switch( iCompareMethod ) + { + case EObjectConditionCompareNone: + break; + + case EObjectConditionCompareId: + { + // Required size for object ID + bufferSize += CMdCSerializationBuffer::KRequiredSizeForTItemId; + } + break; + + case EObjectConditionCompareIds: + { + // Required size for object ID + bufferSize += CMdCSerializationBuffer::KRequiredSizeForTUint32; // count + if( iObjectIds ) + { + bufferSize += CMdCSerializationBuffer::KRequiredSizeForTItemId * iObjectIds->Count(); + } + } + break; + + case EObjectConditionCompareGuid: + { + // Required size for object GUID high (TInt64), object GUID low (TInt64) + bufferSize += 2 * CMdCSerializationBuffer::KRequiredSizeForTInt64; + } + break; + + case EObjectConditionCompareObjectDef: + { + // Required size for object def ID (TUint32) + bufferSize += CMdCSerializationBuffer::KRequiredSizeForTDefId; + } + break; + + case EObjectConditionCompareUri: + case EObjectConditionCompareUriBeginsWith: + case EObjectConditionCompareFreeText: + case EObjectConditionCompareFreeTextContains: + case EObjectConditionCompareFreeTextBeginsWith: + case EObjectConditionCompareFreeTextEndsWith: + { + // Required size for string + bufferSize += CMdCSerializationBuffer::RequiredSize( *iString ); + } + break; + + case EObjectConditionCompareUsageCount: + { + __ASSERT_DEBUG( iRange, User::Panic( _L("Incorrect range condition"), KErrArgument ) ); + bufferSize += iRange->RequiredBufferSize(); + } + break; + + default: + TMdEPanic::Panic( TMdEPanic::EInternal ); + break; + } + + return bufferSize; + } + +void CMdEObjectCondition::SerializeL(CMdCSerializationBuffer& aBuffer, + TMdCOffset& aFreespaceOffset) const + { + const TUint32 conditionOffset = aBuffer.Position(); + const TUint32 subConditionOffset = + conditionOffset + sizeof( TMdCObjectCondition ); + + TMdCObjectCondition condition; + + condition.iConditionType = iType; + condition.iNegated = iNegated; + condition.iConfidentialityLevel = iConfidentialityLevel; + condition.iCompareMethod = iCompareMethod; + condition.iFlags = iFlags; + condition.iCondition = subConditionOffset; + + aBuffer.PositionL( subConditionOffset ); + + switch( iCompareMethod ) + { + case EObjectConditionCompareNone: + { + // nothing to compare, so "clear" condition offset + condition.iCondition = KNoOffset; + } + break; + + case EObjectConditionCompareId: + { + aBuffer.InsertL( iObjectId ); + } + break; + + case EObjectConditionCompareIds: + { + if( iObjectIds ) + { + const TInt count = iObjectIds->Count(); + + aBuffer.InsertL( (TInt32)count ); + + for( TInt i = 0; i < count; i++ ) + { + aBuffer.InsertL( (*iObjectIds)[i] ); + } + } + else + { + aBuffer.InsertL( TInt32( 0 ) ); + } + } + break; + + case EObjectConditionCompareGuid: + { + aBuffer.InsertL( iGuidHigh ); + aBuffer.InsertL( iGuidLow ); + } + break; + + case EObjectConditionCompareObjectDef: + { + aBuffer.InsertL( iObjectDef->Id() ); + } + break; + + case EObjectConditionCompareUsageCount: + { + __ASSERT_DEBUG( iRange, User::Panic( + _L("Incorrect range condition"), KErrArgument ) ); + iRange->SerializeL( aBuffer ); + } + break; + + case EObjectConditionCompareUri: + case EObjectConditionCompareUriBeginsWith: + case EObjectConditionCompareFreeText: + case EObjectConditionCompareFreeTextContains: + case EObjectConditionCompareFreeTextBeginsWith: + case EObjectConditionCompareFreeTextEndsWith: + { + aBuffer.InsertL( *iString ); + } + break; + + default: + { +#ifdef _DEBUG + TMdEPanic::Panic(TMdEPanic::EInternal); +#endif + } + break; + } + + // get position after sub condition + aFreespaceOffset = aBuffer.Position(); + + // serialize condition + aBuffer.PositionL( conditionOffset ); + condition.SerializeL( aBuffer ); + + // and move back to after sub condition + aBuffer.PositionL( aFreespaceOffset ); + }