diff -r 000000000000 -r c53acadfccc6 metadataengine/client/src/mdelogiccondition.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/metadataengine/client/src/mdelogiccondition.cpp Mon Jan 18 20:34:07 2010 +0200 @@ -0,0 +1,491 @@ +/* +* 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 "mdelogiccondition.h" +#include "mdeobjectcondition.h" +#include "mdeboolpropertycondition.h" +#include "mderelationcondition.h" +#include "mdeeventcondition.h" +#include "mdcserializationbuffer.h" +#include "mdcquery.h" + +#include "mdepanic.h" + +EXPORT_C CMdELogicCondition* CMdELogicCondition::NewL(TLogicConditionOperator aOperator) + { + CMdELogicCondition *self = NewLC(aOperator); + CleanupStack::Pop(self); + return self; + } + + +EXPORT_C CMdELogicCondition* CMdELogicCondition::NewLC(TLogicConditionOperator aOperator) + { + CMdELogicCondition *self = new(ELeave) CMdELogicCondition(aOperator); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + + +CMdELogicCondition::CMdELogicCondition(TLogicConditionOperator aOperator) + : CMdECondition(EConditionTypeLogic), iOperator(aOperator) + { + } + + +void CMdELogicCondition::ConstructL() + { + // Base class construction. + ConditionConstruct(); + } + + + +CMdELogicCondition::~CMdELogicCondition() + { + iChildren.ResetAndDestroy(); + iChildren.Close(); + } + + +EXPORT_C TLogicConditionOperator CMdELogicCondition::Operator() const + { + return iOperator; + } + + +EXPORT_C void CMdELogicCondition::SetOperator(TLogicConditionOperator aLogicOperator) + { + AssertNotLocked(); + + __ASSERT_DEBUG(aLogicOperator > ELogicConditionOperatorFirst + && aLogicOperator < ELogicConditionOperatorLast, + TMdEPanic::Panic(TMdEPanic::EInternal)); + + iOperator = aLogicOperator; + } + + +EXPORT_C TInt CMdELogicCondition::Count() const + { + return iChildren.Count(); + } + + +EXPORT_C CMdECondition& CMdELogicCondition::Condition(TInt aIndex) const + { + __ASSERT_DEBUG(aIndex >= 0 && aIndex < Count(), + TMdEPanic::Panic(TMdEPanic::EInternal)); + + return *iChildren[aIndex]; + } + + +EXPORT_C void CMdELogicCondition::Remove(TInt aIndex) + { + AssertNotLocked(); + + __ASSERT_DEBUG(aIndex >= 0 && aIndex < Count(), + TMdEPanic::Panic(TMdEPanic::EInternal)); + + iChildren.Remove(aIndex); + } + +void CMdELogicCondition::SetLocked(TBool aLocked) + { + // Base class locking. + CMdECondition::SetLocked(aLocked); + + const TInt count = iChildren.Count(); + + // Lock children as well. + for(TInt i = 0; i < count; ++i) + { + iChildren[i]->SetLocked(aLocked); + } + } + +TUint32 CMdELogicCondition::InternalQueryOptimizationFlags(TUint32& aFlags) + { + const TInt count = iChildren.Count(); + + // get flag from childrens + for( TInt i = 0 ; i < count; i++) + { + iOptimizationFlags |= iChildren[i]->InternalQueryOptimizationFlags(aFlags); + } + + return 0; + } + + +TUint32 CMdELogicCondition::RequiredBufferSize() const + { + TUint32 bufferSize = sizeof( TMdCLogicCondition ); + + const TInt count = iChildren.Count(); + + // required size for children offsets (children count * TUint32) + bufferSize += count * CMdCSerializationBuffer::KRequiredSizeForTUint32; + + // Required size for childrens + for( TInt i = 0 ; i < count; i++) + { + bufferSize += iChildren[i]->RequiredBufferSize(); + } + + return bufferSize; + } + +void CMdELogicCondition::SerializeL(CMdCSerializationBuffer& aBuffer, + TMdCOffset& aFreespaceOffset) const + { + const TUint32 childrenCount = (TUint32)iChildren.Count(); + + // position after logic condition + const TUint32 conditionOffset = aBuffer.Position() + sizeof( TMdCLogicCondition ); + + TMdCLogicCondition condition; + + condition.iConditionType = iType; + condition.iNegated = iNegated; + condition.iOperator = iOperator; + condition.iOptimizationFlags = iOptimizationFlags; + condition.iChildConditions.iPtr.iCount = childrenCount; + condition.iChildConditions.iPtr.iOffset = conditionOffset; + + condition.SerializeL( aBuffer ); + + // begin position of child condition offsets + TUint32 childOffsetPosition = conditionOffset; + + // begin position of child conditions + TUint32 childPosition = childOffsetPosition + + CMdCSerializationBuffer::KRequiredSizeForTUint32 * childrenCount; + + for( TInt i = 0 ; i < childrenCount; i++) + { + // Move to correct position of children offsets + aBuffer.PositionL( childOffsetPosition ); + + // Insert offset for current child + childOffsetPosition = aBuffer.InsertL( childPosition ); + + // Move to correct position of child + aBuffer.PositionL( childPosition ); + + // Insert current child + iChildren[i]->SerializeL( aBuffer, childPosition ); + } + + // take position after subconditions + aFreespaceOffset = aBuffer.Position(); + } + +EXPORT_C CMdELogicCondition& +CMdELogicCondition::AddLogicConditionL(TLogicConditionOperator aLogicOperator) + { + AssertNotLocked(); + + CMdELogicCondition* condition = NewLC(aLogicOperator); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdEObjectCondition& +CMdELogicCondition::AddObjectConditionL(const CMdEObjectDef& aObjectDef) + { + AssertNotLocked(); + + CMdEObjectCondition* condition = CMdEObjectCondition::NewLC( + EObjectConditionCompareObjectDef, + KNoId, &aObjectDef ); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdEObjectCondition& +CMdELogicCondition::AddObjectConditionL(TItemId aObjectId) + { + AssertNotLocked(); + + CMdEObjectCondition* condition = CMdEObjectCondition::NewLC( + EObjectConditionCompareId, aObjectId ); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdEObjectCondition& +CMdELogicCondition::AddObjectConditionL(const RArray& aObjectIds) + { + AssertNotLocked(); + + CMdEObjectCondition* condition = CMdEObjectCondition::NewLC( + EObjectConditionCompareIds, &aObjectIds ); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdEObjectCondition& +CMdELogicCondition::AddObjectConditionL(TInt64 aObjectGuidHigh, TInt64 aObjectGuidLow) + { + AssertNotLocked(); + + CMdEObjectCondition* condition = CMdEObjectCondition::NewLC( + EObjectConditionCompareGuid, KNoId, NULL, aObjectGuidHigh, aObjectGuidLow); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdEObjectCondition& +CMdELogicCondition::AddObjectConditionL(TObjectConditionCompareMethod aCompareMethod, + const TDesC& aString) + { + AssertNotLocked(); + + CMdEObjectCondition* condition = CMdEObjectCondition::NewLC( + aCompareMethod, NULL, &aString ); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdEObjectCondition& +CMdELogicCondition::AddObjectConditionL(const TMdEUintRange& aRange) + { + AssertNotLocked(); + + CMdEObjectCondition* condition = CMdEObjectCondition::NewLC( + EObjectConditionCompareUsageCount, NULL, NULL, &aRange ); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdEPropertyCondition& +CMdELogicCondition::AddPropertyConditionL(const CMdEPropertyDef& aPropertyDef) + { + AssertNotLocked(); + + CMdEPropertyCondition* condition + = CMdEPropertyCondition::NewLC(aPropertyDef); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdEBoolPropertyCondition& +CMdELogicCondition::AddPropertyConditionL(const CMdEPropertyDef& aPropertyDef, + TBool aBoolValue) + { + AssertNotLocked(); + + CMdEBoolPropertyCondition* condition + = CMdEBoolPropertyCondition::NewLC(aPropertyDef, aBoolValue); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +#define MDE_IMPLEMENT_ADD_RANGE_PROPERTY_CONDITION(RangeType) \ +EXPORT_C CMdE##RangeType##RangePropertyCondition& \ +CMdELogicCondition::AddPropertyConditionL(const CMdEPropertyDef& aPropertyDef, \ + const TMdE##RangeType##Range& aRange) \ + { \ + AssertNotLocked(); \ + CMdE##RangeType##RangePropertyCondition* condition \ + = CMdE##RangeType##RangePropertyCondition::NewLC(aPropertyDef, aRange); \ + AddL(condition); \ + CleanupStack::Pop(condition); \ + return *condition; \ + } + +MDE_IMPLEMENT_ADD_RANGE_PROPERTY_CONDITION(Int) +MDE_IMPLEMENT_ADD_RANGE_PROPERTY_CONDITION(Int64) +MDE_IMPLEMENT_ADD_RANGE_PROPERTY_CONDITION(Uint) +MDE_IMPLEMENT_ADD_RANGE_PROPERTY_CONDITION(Real) +MDE_IMPLEMENT_ADD_RANGE_PROPERTY_CONDITION(Time) + +EXPORT_C CMdETextPropertyCondition& +CMdELogicCondition::AddPropertyConditionL(const CMdEPropertyDef& aPropertyDef, + TTextPropertyConditionCompareMethod aCompareMethod, + const TDesC& aText) + { + AssertNotLocked(); + + CMdETextPropertyCondition* condition + = CMdETextPropertyCondition::NewLC(aPropertyDef, aCompareMethod, aText); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdERelationCondition& +CMdELogicCondition::AddRelationConditionL(TItemId aRelationId, TRelationConditionSide aSide) + { + AssertNotLocked(); + + CMdERelationCondition* condition = CMdERelationCondition::NewLC(aRelationId, NULL, aSide); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdERelationCondition& CMdELogicCondition::AddRelationConditionL( + RArray& aRelationIds, TRelationConditionSide aSide) + { + AssertNotLocked(); + + CMdERelationCondition* condition = CMdERelationCondition::NewLC( + KNoId, &aRelationIds, aSide); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdERelationCondition& +CMdELogicCondition::AddRelationConditionL(TRelationConditionSide aSide) + { + AssertNotLocked(); + + CMdERelationCondition* condition = CMdERelationCondition::NewLC(KNoId, NULL, aSide); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdERelationCondition& +CMdELogicCondition::AddRelationConditionL(const CMdERelationDef& aRelationDef, + TRelationConditionSide aSide) + { + AssertNotLocked(); + + CMdERelationCondition* condition = CMdERelationCondition::NewLC( + KNoId, NULL, aSide, &aRelationDef ); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdERelationCondition& +CMdELogicCondition::AddRelationConditionL(const CMdERelationDef& aRelationDef, + const TMdEIntRange& aParameterRange, + TRelationConditionSide aSide) + { + AssertNotLocked(); + + CMdERelationCondition* condition = CMdERelationCondition::NewLC( KNoId, + NULL, aSide, &aRelationDef, &aParameterRange ); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdEEventCondition& +CMdELogicCondition::AddEventConditionL(TItemId aEventId) + { + AssertNotLocked(); + + CMdEEventCondition* condition = CMdEEventCondition::NewLC(aEventId); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + +EXPORT_C CMdEEventCondition& +CMdELogicCondition::AddEventConditionL(const CMdEEventDef& aEventDef) + { + AssertNotLocked(); + + CMdEEventCondition* condition = CMdEEventCondition::NewLC(KNoId,&aEventDef); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdEEventCondition& +CMdELogicCondition::AddEventConditionL() + { + AssertNotLocked(); + + CMdEEventCondition* condition = CMdEEventCondition::NewLC(); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdEEventCondition& +CMdELogicCondition::AddEventConditionL(const TMdETimeRange& aCreationTimeRange) + { + AssertNotLocked(); + + CMdEEventCondition* condition = CMdEEventCondition::NewLC(KNoId, NULL, &aCreationTimeRange); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdEEventCondition& +CMdELogicCondition::AddEventConditionL(TEventConditionCompareMethod aCompareMethod, + const TDesC& aString) + { + AssertNotLocked(); + + CMdEEventCondition* condition = CMdEEventCondition::NewLC(KNoId, NULL, NULL, aCompareMethod, &aString); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +EXPORT_C CMdEEventCondition& +CMdELogicCondition::AddEventConditionL(const TMdETimeRange& aCreationTimeRange, + TEventConditionCompareMethod aCompareMethod, + const TDesC& aString) + { + AssertNotLocked(); + + CMdEEventCondition* condition = CMdEEventCondition::NewLC(KNoId, NULL, &aCreationTimeRange, aCompareMethod, &aString); + AddL(condition); + CleanupStack::Pop(condition); + return *condition; + } + + +CMdECondition& CMdELogicCondition::AddL(CMdECondition* aCondition) + { + AssertNotLocked(); + + iChildren.AppendL( aCondition ); + return *aCondition; + }